 |
| Simple representation of a stack (Photo credit: Wikipedia) |
Hello Everyone,
Today we will study about the data structure called Stack. But before roceeding with the tutorial I would like to read the following readers note.
Reader's Note :
Now we are good to start, So, Let's Begin.
Stack : A stack is a particular
kind of abstract data type or collection in which the principal (or
only) operations on the collection are the addition of an entity to the
collection. The operations that are performed on the the stack are push which means to insert an element at the top of the stack and pop which means to remove the top element from the stack.
Stack follows LIFO (Last In First Out) Principle, that is the element
which is inserted into a collection last is taken out first from the
collection as well.
The concept of stack data structure is from from development point of
view and it has found numerous applications, include system level design
and making efficient processes.
Applications of Stack
1. Data Parsing
2. Compiler Designing.
3. Recursion
4. Solving numerous Classical problems like Tower of Hanoi.
5. System Memory Management.
6. Reversing String.
7. Mathematical Expression evaluation. (Converting them from infix to postfix and then manipulating evaluating them)
8. Backtracking.
etc...
Stack as an Abstract datatype
push(item) : insert the item into the stack
pop() : removes the top element.
size() : Returns the size of the stack.
isEmpty() : checks whether the stack is empty or not.
isFull() : checks whether the stack is full or not.
Now let us understand the concept of stack better by taking an example :-
Suppose we consider an array of the following elements :-
Now we push another number onto the stack, say 34, then our stack has the following structure :-
So it is evident that the most recently inserted items are push onto the top of the stack following the LIFO principle. Again we push another number into the stack, say 2, just following the above concept we have the following :-
We have understood the push operation and so lets see how does pop works. Lets pop once from the above array and the array becomes :-
As you can see the top element was poped from the stack and the next element that is 34 becomes the top element. Okay so lets pop two more elements and then the stack has the following structure :-
What happened above ?
First 34 is poped and then 5 becomes the top element and then another element i.e. 5 is poped and 6 becomes the top element.
I hope you have understood the concept of stack. Since we have understood the concept of stack and so lets write some code now. I will use Java to write the code. We create an interface to understand the concept of our ADT.
StackInterface.java
JStackArray.java
A Visual or Animated Representation of Stack can be
found here
Okay, We are now ready to study some applications of Stack. So lets begin.
Example of an Application of Stack
String Reverse.
A Stack can be used to reverse a list, integer, string etc. Lets Look at
the following example to understand the concept better :-
Suppose we have a string variable NAME and a string value of "Firun" assigned to it.
String NAME = "Firun";
Now since Stack follows the LIFO principle so if we insert every
character from NAME into the stack then we will have 'n' as the top
element. Then we can pop the elements we will have our Strings reversed.
Look at the following working :-
1. Insert 'F' into Stack. We have
2. Insert 'i' into Stack. We have
3. Subsequently we insert the remaining characters as well and we get the following Stack structure.
'n' <--- Top
'u'
'r'
'i'
'F'
Now we pop all the elements from the stack and we have the following sequence :-
We get 'n'
We get 'u'. Also initially we had 'n' and so now we add 'u' to it and we
get "nu". Proceeding in a similar way we get the final string as
"nuriF".
I hope you understood the logic. So lets peep at the function code :-
private String reverseString(){
String m="";
for(int i=0;i<str.length();i++){
stack.push(str.charAt(i));
}
for(int i=0;i<str.length();i++){
m=m+stack.pop();
}
return m;
}
Algorithm
PROCEDURE REVERSE_STRING(M) {
INITIALISE LEN = LENGTH(M)
FOR I TO LEN:
STACK.PUSH(M[I])
FOR I TO LEN:
N = N + STACK.POP()
RETURN N
}
If you are able to make it to this end then it probably means that you
have read the tutorial. I hope you enjoyed it. If you have any questions
or doubts then feel free to ask.
Stacks are very useful and they reduce your workload, but it solely
depends on the programmer how efficiently he uses these concepts. More
applications of Stack like Conversion to different notations and Tower
of Hanoi will be covered separately.
Feedback would be appreciated. Comment in the comment section below.
Thank you,
Sincerely,
Psycho_Coder.
![[Image: crypto_types.gif]](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_u0cXNq7SQjUTa9nO2T65b3QgJdbn89z3toFjmp7H4E1ii5XN8Jsxyg5FT4l-pUTorjOi7lTYT4_yhWphmmR48SH3_L47xiQPEgrL_arksRJdDsT9V286wLaVKCmw=s0-d)
![[Image: hoRwHam.png]](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_u7YS0WN-uMBW4H4nd8dsedhH7o1czhUqWai8aqv4GUsdTdXtjoX8l-D01SRh4AR9ws9h-Vh6UL3XCyNH5G8tD1JA=s0-d)
![[Image: dbh35lX.png]](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_uaFDChBTC-ZdSQj1OBXj8GmdneJ-qIyx38VnFkwCkz_0VBc43KTcre5W9lD4JC99aCF9dzOLvsvi1k79QOacaXtQ=s0-d)
![[Image: MnpRetD.jpg]](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_sQgfkEX9ml1QbUusOyqPuREFB2wYasYfPxseNDgxArFpP_A-K_6S9oc75Ep6giupIVbedA6fj9BNMS945bcPHqGg=s0-d)
![[Image: W82K5YX.jpg]](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_sV_5SFXc0XeTYVrh9IxpKzKRIqV046-k0y2N9xTJJj9KQIn6qcE9YeZw5Zxu1yPpDdCz3OLBz7DGRNYcA_crqf0g=s0-d)
![[Image: 9aRw1lA.jpg]](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_tg1_Rrkk5eGGTPtemgSRke44sYOgBW_uD75Y44UiKr-WqS9WX0bipREgvZfijD-gpuBKjujQwkXe0qRtOazfdvSA=s0-d)
