Skip to content

Understanding the difference between Queue and Stack Data Structure

A common concept most software developers have to deal with on a daily basis is working with data and managing data so that it can be worked on. Typically developers will conceptually need to temporarily store data while processing it and this will typically require some sort of data structure , which is a mechanism to organise data for management and storage format to enable efficient access and modification. At its core a data structure is a collection of data values and the relationships among them and the functions and operations that be applied to the data.

Different types of data structures are suited to different applications and some are suited to to highly specific types of tasks. The most commonly found data structures most software developers will be familiar with are Queues and Stacks.

What is a Stack ?

A stack is a linear data structure in which elements can be inserted and deleted only from one side of the list, commonly referred to as the top. Typically a stack data structures follows the LIFO (Last In First Out) principle

What is the LIFO principle

 It is a method for handling data structures where the first element is processed last and the last element is processed first. The insertion of an element into stack is called push operation, and deletion of an element from the stack is called pop operation.

C# Stack<T>

To make use of Stacks in C# use the generic Stack<T> collection, which is useful useful to store temporary data in LIFO style, and you might want to delete an element after retrieving its value.

Create Stack

You can create an object of the Stack<T> by specifying a type parameter for the type of elements it can store. 

// Create an int Stack
Stack<int> myStack = new Stack<int>();

// Create a string stack
Stack<string> myStack = new Stack<string>();

// create a double stack
Stack<double> myStack = new Stack<double>();

Stack<CustomClass> myStack = new Stack<CustomClass>();
Methods
MethodDescription
Push(T)Inserts an item at the top of the stack
Peek()Returns top item from the stack
Pop()Removes and returns items from the top of the stack
Contains(T)Checks whether an item exists in the stack or not
Clear()Removes all items from the stack
Properties
PropertyDescription
CountReturns the total count of elements in the stack
 class Program
    {
        static void Main(string[] args)
        {
            // Create and Add items to a stack
            Stack<int> stack = new Stack<int>();

            for (int i = 0; i < 5; i++)
                stack.Push(i);
            
            Console.Write("Elements of stack: ");
            stack.ToList().ForEach(x => Console.Write($"{x.ToString()} "));
            Console.WriteLine(Environment.NewLine);
            
            Console.WriteLine("Going to Pop element off stack");

         
            Console.WriteLine($"removed element {stack.Pop().ToString()}");
            
            Console.Write("Elements of Stack: ");
            stack.ToList().ForEach(x => Console.Write($"{x.ToString()} "));
            Console.WriteLine(Environment.NewLine);
            
            Console.WriteLine("View the head of stack");
            Console.WriteLine($"head of stack- {stack.Peek().ToString()}");
            Console.WriteLine(Environment.NewLine);
            
           
            Console.WriteLine($"Size of stack- {stack.Count}");
            
            Console.WriteLine($"Add element to stack");
            stack.Push(5);
            Console.Write("Elements of Stack: ");
            stack.ToList().ForEach(x => Console.Write($"{x.ToString()} "));
            Console.WriteLine(Environment.NewLine);
        }
    }

The output of the above code will appear as follows

Elements of stack: 4 3 2 1 0 

Going to Pop element off stack
removed element 4
Elements of Stack: 3 2 1 0 

View the head of stack
head of stack- 3


Size of stack- 4
Add element to stack
Elements of Stack: 5 3 2 1 0 

What is a Queue ?

 A queue is a linear data structure in which elements can be inserted only from one side of the list called rear, and the elements can be deleted only from the other side called the front. The queue data structure follows the FIFO (First In First Out) principle.

What is FIFO principle

 It is a method for handling data structures where the first element is processed first and the newest element is processed last.

C# Queue<T>

To make use of Queues in It is recommended to use the generic Queue<T> collection.

/ Create an int Stack
Queue<int> queue = new Queue<int>();

// Create a string stack
Queue<string> queue = new Queue<string>();

// create a double stack
Queue<double> queue = new Queue<double>();

Queue<CustomClass> queue = new Queue<CustomClass>();
Methods
MethodDescription
Enqueue(T)Adds an item into the queue.
Dequeue()Returns an item from the beginning of the queue and removes it from the queue.
Peek(T)Returns an first item from the queue without removing it.
Contains(T)Checks whether an item is in the queue or not
Clear()Removes all the items from the queue
Property
PropertyDescription
CountReturns the total count of elements in the Queue
 class Program
    {
        static void Main(string[] args)
        {
            Queue<int> queue = new Queue<int>();

            // Adds elements {0, 1, 2, 3, 4} to queue
            for (int i = 0; i < 5; i++)
                queue.Enqueue(i);

            // Print out Elements of the Queue
            Console.Write("Elements of Queue: ");
            queue.ToList().ForEach(x => Console.Write($"{x.ToString()} "));
            Console.WriteLine(Environment.NewLine);
            
            // To remove the head of queue.
            // In this the oldest element '0' will be removed
            Console.WriteLine("Going to Dequeue element");

         
            Console.WriteLine($"removed element {queue.Dequeue().ToString()}");

            Console.Write("Elements of Queue: ");
            queue.ToList().ForEach(x => Console.Write($"{x.ToString()} "));
            Console.WriteLine(Environment.NewLine);

            Console.WriteLine("View the head of queue");
           Console.WriteLine($"head of queue- {queue.Peek().ToString()}");
            Console.WriteLine(Environment.NewLine);
            
           
            Console.WriteLine($"Size of queue- {queue.Count}");
            
            //Add another item to queue
            Console.WriteLine("Add new element to queue");
            queue.Enqueue(5);
            
            Console.Write("Elements of Queue: ");
            queue.ToList().ForEach(x => Console.Write($"{x.ToString()} "));
            Console.WriteLine(Environment.NewLine);
        }
    }

The output of the above code will appear as follows

Elements of Queue: 0 1 2 3 4 

Going to Dequeue element
removed element 0
Elements of Queue: 1 2 3 4 

View the head of queue
head of queue- 1


Size of queue- 4
Add new element to queue
Elements of Queue: 1 2 3 4 5 

Differences between Stack and Queue data structures

StackQueue
LIFO PrincipleFIFO Principle
Insert and Remove at TOP onlyInsert at the Rear and Remove from the Front
PUSH Operation to insertEnqueue operation to insert
POP operation to deleteDequeue operation to delete
Only one pointer to access the list, pointing to last element in the listTwo pointers to access the list. Pointing to the First element in the list and to the last inserted element
used in solving problems works on recursion.used in solving problems having sequential processing


https://github.com/garywoodfine/datastructures
0 forks.
0 stars.
0 open issues.

Recent commits:

Gary Woodfine
Latest posts by Gary Woodfine (see all)