07_Stack.cs

using System;
using System.Collections.Generic;

namespace DataStructures
{
    /// <summary>
    /// Demonstrates the Stack<T> collection in C# (LIFO — Last In, First Out).
    /// Elements are pushed onto the top and popped from the top.
    /// 
    /// Common use cases: undo/redo operations, expression evaluation,
    /// depth-first search (DFS), browser history, bracket matching,
    /// digit decomposition, call stacks.
    /// </summary>
    public class StackExamples
    {
        // ─── Entry Point ───────────────────────────────────────────────
        public static void Main()
        {
            Console.WriteLine("═══════════════════════════════════════════════");
            Console.WriteLine("           C# Stack<T> Examples                ");
            Console.WriteLine("═══════════════════════════════════════════════\n");

            // ── 1. Basic Push / Pop / Peek ──────────────────────────────
            Console.WriteLine("── Basic Push / Pop / Peek ────────────────────");
            var stack = new Stack<string>();

            // Push — add elements to the top
            stack.Push("First");
            stack.Push("Second");
            stack.Push("Third");
            stack.Push("Fourth");

            Console.WriteLine($"  Stack (top→bottom): {string.Join(", ", stack)}");
            Console.WriteLine($"  Count: {stack.Count}");
            Console.WriteLine();

            // Peek — view the top element without removing it
            Console.WriteLine($"  Peek() → \"{stack.Peek()}\" (stack unchanged)");
            Console.WriteLine($"  Count after Peek: {stack.Count}");
            Console.WriteLine();

            // Pop — remove and return the top element (LIFO)
            Console.WriteLine("  Popping all elements:");
            while (stack.Count > 0)
            {
                string item = stack.Pop();
                Console.WriteLine($"    Popped: \"{item}\" | Remaining: {stack.Count}");
            }
            Console.WriteLine();

            // ── 2. Number Digit Decomposition ──────────────────────────
            Console.WriteLine("── Digit Decomposition using Stack ───────────");
            int number = 12345;
            Console.WriteLine($"  Original number: {number}");

            var digitStack = new Stack<int>();
            int temp = number;

            // Push each digit onto the stack
            while (temp > 0)
            {
                digitStack.Push(temp % 10);   // Extract last digit
                temp /= 10;                    // Remove last digit
            }

            Console.WriteLine($"  Digits (stack order): {string.Join(", ", digitStack)}");

            // Pop digits — reveals them in reverse order
            Console.WriteLine("  Popping digits (reversed):");
            while (digitStack.Count > 0)
            {
                Console.WriteLine($"    Digit: {digitStack.Pop()}");
            }
            Console.WriteLine();

            // Reverse the number using stack
            temp = number;
            var reverseStack = new Stack<int>();
            while (temp > 0)
            {
                reverseStack.Push(temp % 10);
                temp /= 10;
            }
            // Build reversed number
            int reversed = 0;
            int multiplier = 1;
            while (reverseStack.Count > 0)
            {
                reversed += reverseStack.Pop() * multiplier;
                multiplier *= 10;
            }
            Console.WriteLine($"  Reversed number: {reversed}");
            Console.WriteLine();

            // ── 3. ASCII Character Stack ────────────────────────────────
            Console.WriteLine("── ASCII Character Stack ─────────────────────");
            var charStack = new Stack<char>();

            // Push ASCII characters A–E
            for (char c = 'A'; c <= 'E'; c++)
            {
                charStack.Push(c);
                Console.WriteLine($"  Pushed: '{c}' (ASCII {(int)c})");
            }

            Console.WriteLine($"  Stack: [{string.Join(", ", charStack)}]");

            // Pop and show characters in reverse
            Console.WriteLine("  Popping (LIFO — reverse of push order):");
            while (charStack.Count > 0)
            {
                char ch = charStack.Pop();
                Console.WriteLine($"    '{ch}' — ASCII {(int)ch}");
            }
            Console.WriteLine();

            // ── 4. ToArray & Contains ──────────────────────────────────
            Console.WriteLine("── ToArray / Contains ────────────────────────");
            var nums = new Stack<int>();
            nums.Push(10);
            nums.Push(20);
            nums.Push(30);

            int[] arr = nums.ToArray();
            Console.WriteLine($"  Stack: {string.Join(", ", nums)}");
            Console.WriteLine($"  Array: {string.Join(", ", arr)}");
            Console.WriteLine($"  Contains(20): {nums.Contains(20)}");
            Console.WriteLine($"  Contains(99): {nums.Contains(99)}");

            Console.WriteLine("\n═══════════════════════════════════════════════");
            Console.WriteLine("  Complexity: Push O(1) | Pop O(1) | Peek O(1)");
            Console.WriteLine("  Contains O(n) | ToArray O(n)");
            Console.WriteLine("═══════════════════════════════════════════════");
        }
    }
}