Stacks in C#

Introduction

Greetings, Space Explorer! Today, we're drawing back the curtains on Stacks in C#, a crucial data structure. A stack is like a pile of dishes: you add a dish to the top (Last In) and take it from the top (First Out). This Last-In, First-Out (LIFO) principle exemplifies the stack. C# executes stacks effortlessly using the Stack class from the System.Collections.Generic namespace. This lesson will illuminate the stack data structure, its operations, and its applications in C#. Are you ready to start?

Utilizing Stacks in C#

To create a stack, C# employs a built-in data structure known as a Stack . For the push operation, we use Push(), which adds an element to the stack's end. For the pop operation, there's the Pop() function that removes the last element, simulating the removal of the 'top' element in a stack. Here's how it looks: C# using System; using System.Collections.Generic; public class StackExample {public static void Main(string[] args) {Stack<string> stack = new Stack<string>(); // A new empty stack // Push operations stack.Push("John"); stack.Push("Mary"); stack.Push("Steve"); stack.Pop(); // Pop operation removes 'Steve' Console.WriteLine(string.Join(" -> ", stack)); // Outputs: John -> Mary}} In the example provided, we push John, Mary, and Steve into the stack and then pop Steve from the stack.

Advanced Stack Operations

Stack operations go beyond merely Push and Pop . For example, to verify if a stack is empty, we can check if the Count property is 0 . If it is, that means the stack is empty. To peek at the top element of the stack without popping it, we use the Peek() method. Here's an example: C# using System; using System.Collections.Generic; public class StackOperations {public static void Main(string[] args) {Stack<string> stack = new Stack<string>(); stack.Push("Steve"); stack.Push("Sam"); Console.WriteLine(stack.Peek()); // Outputs: 'Sam' Console.WriteLine(stack.Count == 0); // Outputs: False stack.Pop(); // Remove 'Sam' stack.Pop(); // Remove 'Steve' Console.WriteLine(stack.Count == 0); // Outputs: True}} In this example, Sam is added (pushed), and then the topmost stack element, which is Sam, is peeked at.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Practical Stack Applications: Checking Balance of Parentheses

A stack can be utilized to verify if parentheses in an expression are well-matched, i.e., every bracket has a corresponding pair. For example, parentheses in the string "()[{}]" are well-matched, while in strings "([]()", ")()[]{}", "([)]", and "[{})" they are not.

Let's break down the solution into simple steps:

We start by creating a Dictionary that maps each closing bracket to its corresponding opening bracket and an empty stack. Then, we iterate over each character paren in the string parenString:

If paren is an opening bracket, it gets appended to the stack.
If paren is a closing bracket and the top element in the stack is the corresponding opening bracket, we remove the top element from the stack.
If neither of the above conditions is met, we return false.

Finally, if the stack is empty (all opening brackets had matching closing brackets), we return true. If there are some unmatched opening brackets left, we return false.

using System;
using System.Collections.Generic;

public class ParenthesesBalance
{
    public static bool IsParenBalanced(string parenString)
    {
        Stack<char> stack = new Stack<char>();
        Dictionary<char, char> openingParen = new Dictionary<char, char>
        {
            { ')', '(' },
            { ']', '[' },
            { '}', '{' }
        };

        foreach (char paren in parenString)
        {
            if (openingParen.ContainsValue(paren))
            {
                // We met an opening parenthesis, just putting it on the stack
                stack.Push(paren);
            }
            else if (openingParen.ContainsKey(paren))
            {
                // We met a closing parenthesis
                if (stack.Count == 0 || stack.Pop() != openingParen[paren])
                {
                    return false;
                }
            }
        }

        return stack.Count == 0;
    }

    public static void Main(string[] args)
    {
        Console.WriteLine(IsParenBalanced("(())")); // Outputs: True
        Console.WriteLine(IsParenBalanced("({[)}")); // Outputs: False
    }
}

using System;
using System.Collections.Generic;

public class ParenthesesBalance
{
    public static bool IsParenBalanced(string parenString)
    {
        Stack<char> stack = new Stack<char>();
        Dictionary<char, char> openingParen = new Dictionary<char, char>
        {
            { ')', '(' },
            { ']', '[' },
            { '}', '{' }
        };

        foreach (char paren in parenString)
        {
            if (openingParen.ContainsValue(paren))
            {
                // We met an opening parenthesis, just putting it on the stack
                stack.Push(paren);
            }
            else if (openingParen.ContainsKey(paren))
            {
                // We met a closing parenthesis
                if (stack.Count == 0 || stack.Pop() != openingParen[paren])
                {
                    return false;
                }
            }
        }

        return stack.Count == 0;
    }

    public static void Main(string[] args)
    {
        Console.WriteLine(IsParenBalanced("(())")); // Outputs: True
        Console.WriteLine(IsParenBalanced("({[)}")); // Outputs: False
    }
}

Introduction

Utilizing Stacks in C#

Advanced Stack Operations

Join the 1M+ learners on CodeSignal

Practical Stack Applications: Reversing a String

Practical Stack Applications: Checking Balance of Parentheses

Lesson Summary