In the world of C# programming, understanding data structures is crucial for building efficient and scalable applications. In this post, we'll dive into the fundamental concepts of data structures by focusing on two essential ones: the stack and the queue. We'll explore what these data structures are, how they work, and most importantly, how to implement them in C#. Whether you're a seasoned developer looking to refresh your knowledge or a newcomer eager to grasp these essential concepts, this article will provide you with a solid foundation for handling data in your C# projects. Let's get started!

A LIFO stack

A Last-In, First-Out stack is a datastructure that operate in a manner where the last element added to the stack is the first one to be removed. Imagine a stack of plates - you add a new plate on top and take the most recently added plate off the top. LIFO stacks are incredibly versatile and find application in various programming scenarios, from function call management in memory to parsing expressions and handling undo/redo functionality in software applications.

Let's implement a C# version of a stack, based an the List collection. we have two main methods for making things work. With the push method we can add a new item to the stack, and with the pop metod we can get and remove an item from the stack. The code is pretty simple:

 public class Stack<T>{

  private List<T> stack = new List<T>();

  public Stack() { 
    stack = new List<T>();
  }
  public void Push(T item) {
    stack.Add(item);
  }

  public T Pop() {
    if (stack.Count < 1) throw new InvalidOperationException();

    var last_idx = stack.Count - 1;
    var last = stack[last_idx];
    stack.RemoveAt(last_idx);
    return last;
  }
}

There are also other useful methods to implement in a stack, for example the Peek method allows you to access the next element without removing it. You can find the complete, commented and easy-to-read code on the GitHub repository.

A FIFO queue

A First-In, First-Out (FIFO) operates on the principle that the first item added to the queue is the first one to be removed. This ensures that data is processed in the order it was received, making it an essential tool for scenarios where maintaining sequence matters, such as task scheduling or managing requests in a web server. In a FIFO stack, elements are enqueued at the back and dequeued from the front, just like people waiting in line.

Let's implement a C# version of a queue. We need the enqueue method to add a new item into the queue and de dequeue method to get and remove the next element.

public class Queue<T> {
    
  private List<T> queue = new List<T>();

  public Queue() {
      queue = new List<T>();
  }

  public void Enqueue(T item) {
    queue.Add(item);
  }

  public T Dequeue() {
      if (queue.Count < 1) throw new InvalidOperationException();

      var first = queue[0];
      queue.RemoveAt(0);
      return first;
  }
}

Also in this case this class is not complete, you can read the full code here.

In conclusion, a solid grasp of data structures is essential for any C# programmer, and in this article, we've explored two fundamental ones: the FIFO (First-In, First-Out) queue and the LIFO (Last-In, First-Out) stack. Whether you're looking to manage tasks in a sequence or handle complex data processing, these data structures are your reliable allies. By understanding their principles and learning how to implement them in C#, you'll be well-prepared to design more efficient and organized software solutions. Both FIFO and LIFO stacks play pivotal roles in solving real-world programming challenges, and your newfound knowledge of these structures is a valuable asset in your coding journey.

C#SE is an open source content series dedicated to algorithm and data structures in C#. You can find the repository on GitHub

Follow @gslf Star Sponsor