C# Stacks and Queues
Tags: csharp, programming, shorts, dotnet
Published: 2022-01-17 10:13:08

In the New Year I've decided that in order to become a better developer I need to  expand my knowledge of C# and have begun to trawl through the Microsoft Documentation to help me do so. 
I believe this should improve my problem solving abilities and provide me with new tools and ways of thinking. It seems like a no-brainer.
During my searching I've recently "discovered" a few things I had never seen before. 
I say discovered but its not like they were exactly hidden - I'd just never needed these things before. Those things are `Stack` and `Queue`. 

### What are they  ?
Simply put they're both types of Collections, they're just more limited in how you access the elements in them, we'll see both below : 



 

#### **Stack**

Stack is a type of Collection that stores objects on a basis of last in first out (LIFO).

You can only retrieve and / or remove items at the end of the stack, and items added will be added at the end.

No exceptions.

 

It is recommended to use the generic Stack from `System.Collection.Generic` namespace. rather than non-generic type.

 

##### **Methods**

1. Clear - Remove all objects from the Stack.

2. Contains - Used to check if an item is in the Stack.

3. Push - Adds an item to the end of the Stack.

4. Pop - Removes an item from the end of the Stack. If the Stack is empty it will throw an error.

5. Peek - Returns the item at the end of the Stack __without removing it__ .

 

This method list is not complete, just the most relevant in my opinion - there are others like `ToArray()` , `ToString()` etc   but these are common to other Collection types as well so theres no need to go into detail.

 

```csharp

//Initialize

Stack<int> example = new Stack<int>();

//Add to Stack

example.Push(1);

example.Push(2);

example.Push(3);

//View last added element in Stack

int p1 = example.Peak();

//Get and remove the last added item from the Stack

int p2 =  example.Pop();

```

 

#### **Queue**

Queue is the opposite of this - it operates on the basis of first in first out (FIFO).

You can think of it like people queuing for tickets - only those at the front can buy and leave the queue,

while anyone added to the queue is adde to the end.

 

It is recommended to use the generic Queue from `System.Collection.Generic` namespace. rather than non-generic type.

 

##### **Methods**

1. Clear - Remove all objects from the

2. Contains - Used to check if an item is in the Queue

3. Dequeue  - Removes an item from the begining of the Queue

4. Enqueue - Adds an item to the end of the Queue

5. Peek - Returns the item at the start of the Queue __without removing it__ .

 

This method list is not complete, just the most relevant in my opinion - there are others like `ToArray()` , `ToString()` etc   but these are common to other Collection types as well so theres no need to go into detail.

 

```csharp

//Initialize Queue

Queue<int> example = new Queue<int>();

//Add to Queue

example.Enqueue(1);

example.Enqueue(2);

example.Enqueue(3);

//View first element in Queue

int p1 = example.Peak();

//Get and remove the first element in the Queue

int p2 =  example.Dequeue();

```

#### Ok now what ? 
Now I know what you're thinking after reading the above   
"Why can't I just use a `List` anyway" 

Well you can if you want, and there's nothing wrong with it. But using Stacks and Queues both limits the access direction and I think most importantly it displays the _intent_ of how the collection should be used to your fellow programmers. 

That _intent_ I think is the real gem here. 


#### Adios
Well that's it, they're straight forward enough. 
 
Feel free to ask questions, comment or contribute below!

And if you're feeling generous you can buy me a coffee with the link below ( and yes its all for coffee,  I drink a copious amount of it while writing ☕ )  


[![Buy Me A Coffee](https://cdn.buymeacoffee.com/buttons/default-black.png)](https://www.buymeacoffee.com/SUKaQp9)