C# Stack Class

Stack is a non-generic collection class which is used to maintain a last-in, first-out(LIFO) collection of objects i.e. the last element to enter the Stack is the first one to be removed. In other words, Stack can be thought of as a pile of dishes, a new dish is always added to the top of the pile and the first dish to be removed is from the top as well.

Note: Stack implements the ICollection, IEnumerable, and ICloneable interfaces.

Important features of Stack

New elements are always added at the end of a Stack.
Elements are removed from the end of a Stack.
Duplicate elements are allowed to be stored in a Stack.
As a Stack maintains a LIFO collection of objects, so you may use Stack when you need to access the information in reverse order.
To iterate over the elements of a Stack, we could use a foreach loop.

Constructors of Stack

Constructor	Description
Stack()	This constructor creates an empty instance of the Stack class by using the default initial capacity. The capacity of a Stack is the number of elements it can hold, as the new elements are added to the Stack, its capacity is automatically increased.
Stack(int capacity)	This constructor creates a Stack that is empty and has specified its initial capacity.
Stack(ICollection)	This constructor creates a Stack initialized with the elements of an ICollection.

Properties of Stack:

Properties	Description
Count	This property gives total number of elements in a Stack.
IsSynchronzied	This property determines whether a Stack is thread-safe or not.
SyncRoot	Thie property gets an object that can be used to synchronize access to a Stack.

Some commonly used methods of Stack class

Methods	Description
Object Pop()	This method removes and returns the object at the top of a Stack.
Object Push(Object ob)	This method inserts an object at the top of a Stack.
Object Peek()	This method returns an object at the top of a Stack without removing it.
bool Contains(Object o)	This method checks if Stack contains a specific Object.
void Clear()	This method removes all of the elements from a Stack.
IEnumerator GetEnumerator()	This method returns an IEnumerator to enumerate an entire Stack.
Object[ ] ToArray()	This method returns an Object array containing all the elements of a Stack.

An example of Stack

In this program we have created a Stack to hold objects and we will add and remove objects from this Stack using its methods described above in the table. Let's see the code now -:

//C# Example of a Stack

using System;
using System.Collections;

class Stack1
{
public static void Main(String[] ar)
{
	//Creating a Stack
	Stack st= new Stack();
	

	//Calling the Push() method to push elements into the Stack
	//New element is always added to the top of the Stack
	st.Push(10);
	st.Push(23);
	st.Push(16);
	st.Push(5);
	st.Push(29);

	//Printing the contents of Stack
	Console.WriteLine("The contents of Stack: ");
	foreach(int element in st)
		Console.WriteLine(element);


	//Calling the Pop() method to remove the top element of the Stack
	Console.WriteLine("Popping out the top element = "+ st.Pop());
	Console.WriteLine("Popping out the next top element = "+ st.Pop());


	//Calling the Peek() method which only gets the top element of the Stack, without removing it
	Console.WriteLine("Peeking at the current top element = "+ st.Peek());


	//Printing the updated contents of Stack
	Console.WriteLine("Updated contents of Stack: ");
	foreach(int element in st)
		Console.WriteLine(element);
}
}

Output is :

The contents of Stack:
29
5
16
23
10
Popping out the top element = 29
Popping out the next top element = 5
Peeking at the current top element = 16
Updated contents of Stack:
16
23
10

Program Analysis

The method Push() is called to add the elements to the top of Stack and its contents are printed using foreach loop.
The method Pop() is called, which returns and removes the first/top element from the Stack i.e. 29.
The method Pop() is called again, which returns and removes the next first/top element from the Stack i.e. 5.
The method Peek() is called, which returns(but doesn't remove) the element from the top of Stack i.e. 16 and the updated contents of Stack are displayed.

Converting a Stack to an Object array

In the upcoming program, we will call the ToArray() method, which returns an Object array containing all the elements of the invoked Stack.

//C# Example of a Stack

using System;
using System.Collections;

class Stack1
{
public static void Main(String[] ar)
{
	//Creating a Stack
	Stack st= new Stack();
	

	//Calling the Push() method to push elements into the Stack
	//New element is always added to the top of the Stack
	st.Push(10);
	st.Push(23);
	st.Push(16);
	st.Push(5);
	st.Push(29);

	//Printing the contents of Stack
	Console.WriteLine("The contents of Stack: ");
	foreach(int element in st)
		Console.WriteLine(element);

	//Calling the ToArray() method of Stack
	Object[] obArr = st.ToArray();


	//Printing the contents of Object array
	Console.WriteLine("The contents of Object array initialized from the elements of Stack: ");
	foreach(Object element in obArr)
		Console.WriteLine(element);
}
}

Output is :

The contents of Stack:
29
5
16
23
10
The contents of Object array initialized from the elements of Stack:
29
5
16
23
10

Program Analysis

The method Push() is called to add the elements to the top of Stack and its contents are printed using foreach loop.
The method ToArray() is called, which returns an Object array containing all the elements of the invoked Stack.
The objects within the Object array are iterated and displayed within a foreach loop.

Please share this article -

Please Subscribe

Please subscribe to our social media channels for daily updates.

Notifications

Please check our latest addition

C#, PYTHON and DJANGO