stack data structure in python
------------------------------
introduction:
~~~~~~~~~~~~~
=> a stack is linear data structure.
=> memory allocation for objects are continueos memory locations.
=> last - in - first - out LIFO
Eg:
---
stack of plates
disks in the rack
function calls are stored inside stack
web page navigations
parenthesis balancing
reversing item
infix to prefix/postfix
evaluation of prefix/postfix
undo/redo or forward/backward
etc
operations that can be performed on stack
-----------------------------------------
The following are some of operations that can be performed on stack
1) push ---> inserting an object into stack
2) pop ----> deleteing an object from stack
3) peek ---> returning top most object in the stack
4) size ---> returns num of objects in the stack
5) isempty-> returns True if the stack is empty else False
6) display-> display/traverse elements in the stack
implementation of stack
-----------------------
container and top
when an obj is inserted top will be incremented by one unit
when an obj is deleted top will be decremented by one unit
1) using list
2) collections. deque
3) using our own implementation
stack implementation by using list
----------------------------------
L = []
print(L) #[]
L.append(111)
L.append(222)
L.append(333)
L.append(444)
L.append(555)
print(L) #[111, 222, 333, 444, 555]
print(L[-1]) #555
print(L) #[111, 222, 333, 444, 555]
L.pop()
print(L) #[111, 222, 333, 444]
print(len(L)==0)
print(len(L))
C:\test>py test.py
[]
[111, 222, 333, 444, 555]
555
[111, 222, 333, 444, 555]
[111, 222, 333, 444]
False
4
stack implementation by using collections.deque
------------------------------------------------
from collections import deque
stack = deque()
stack.append(10)
stack.append(20)
stack.append(30)
stack.append(40)
print(stack) #[10,20,30,40]
print(stack[-1]) #40
stack.pop()
print(stack)
C:\test>py test.py
deque([10, 20, 30, 40])
40
deque([10, 20, 30])
stack implementation by our own list
------------------------------------
class stack:
#constructor for initializations
def __init__(self):
self.stk = []
#isempty operation
def isempty(self):
return len(self.stk)==0
#size of stack
def size(self):
return len(self.stk)
#print or display or traversing
def display(self):
print(self.stk)
#push operation
def push(self,data):
self.stk.append(data)
#pop operation
def pop(self):
if self.isempty():
print("stack is underflow")
return
return self.stk.pop()
s = stack()
s.push(111)
s.push(222)
s.display()
print(s.pop())
s.display()
C:\test>py test.py
[111, 222]
222
[111]
stack implementation by using linked list
-----------------------------------------
class stack:
class node:
def __init__(self,data,next=None):
self.data = data
self.next = next
#constructor for initializations
def __init__(self):
self.head = None
self.count = 0
#isempty operation
def isempty(self):
return self.count==0
#peek operation
def peek(self):
if self.isempty():
print("stack is empty")
return
return self.head.data
#size of stack
def size(self):
return self.count
#print or display or traversing: O(n)
def display(self):
if self.isempty():
print("list is empty")
return
temp = self.head
while temp!=None:
print(temp.data,end=" ")
temp = temp.next
print()
#push operation
def push(self,data):
self.head = self.node(data,self.head)
self.count = self.count + 1
#pop operation
def pop(self):
if self.isempty():
print("stack is underflow")
return
val = self.head.data
self.count = self.count -1
self.head = self.head.next
return val
s = stack()
s.push(100)
s.push(200)
s.push(300)
s.display()
print(s.pop())
s.display()
print(s.peek())
print(s.size())
C:\test>py test.py
300 200 100
300
200 100
200
2
system stack and function calls
-------------------------------
def fun2():
print("function2 line num 1")
def fun1():
print("function1 line num 1")
fun2()
print("function1 line num 2")
def main():
print("main line num 1")
fun1()
print("main line num 2")
main()
'''
main line num1
function1 line num 1
function2 line num 1
function1 line num 2
main line num 2
'''
stack.py
--------
class stack:
class node:
def __init__(self,data,next=None):
self.data = data
self.next = next
#constructor for initializations
def __init__(self):
self.head = None
self.count = 0
#isempty operation
def isempty(self):
return self.count==0
#peek operation
def peek(self):
if self.isempty():
print("stack is empty")
return
return self.head.data
#size of stack
def size(self):
return self.count
#print or display or traversing: O(n)
def display(self):
if self.isempty():
print("list is empty")
return
temp = self.head
while temp!=None:
print(temp.data,end=" ")
temp = temp.next
print()
#push operation
def push(self,data):
self.head = self.node(data,self.head)
self.count = self.count + 1
#pop operation
def pop(self):
if self.isempty():
print("stack is underflow")
return
val = self.head.data
self.count = self.count -1
self.head = self.head.next
return val
stack to maintain student objects
---------------------------------
from stack import *
class student:
def __init__(self,sid,sname):
self.sid = sid
self.sname = sname
def __str__(self):
return f"({self.sid}, {self.sname})"
s1 = student(111,"AAA")
s2 = student(222,"BBB")
s3 = student(333,"CCC")
s4 = student(444,"DDD")
s = stack()
s.push(s1)
s.push(s2)
s.push(s3)
s.push(s4)
s.display()
print(s.pop())
s.display()
C:\test>py test.py
(444, DDD) (333, CCC) (222, BBB) (111, AAA)
(444, DDD)
(333, CCC) (222, BBB) (111, AAA)
sorted insertion into stack
---------------------------
from stack import *
def sortedinsert(s,data):
if s.isempty() or data>s.peek():
s.push(data)
else:
temp = s.pop()
sortedinsert(s,data)
s.push(temp)
s = stack()
sortedinsert(s,4)
sortedinsert(s,5)
sortedinsert(s,1)
sortedinsert(s,2)
sortedinsert(s,3)
sortedinsert(s,6)
s.display()
sorting stack elements
----------------------
from stack import *
def sortedinsert(s,data):
if s.isempty() or data>s.peek():
s.push(data)
else:
temp = s.pop()
sortedinsert(s,data)
s.push(temp)
def sortstack(s):
if not s.isempty():
temp = s.pop()
sortstack(s)
sortedinsert(s,temp)
s = stack()
s.push(444)
s.push(111)
s.push(222)
s.push(333)
s.push(666)
s.push(555)
s.display()
sortstack(s)
s.display()
bottom insert in the stack
--------------------------
from stack import *
def bottominsert(s,data):
if s.isempty():
s.push(data)
else:
temp = s.pop()
bottominsert(s,data)
s.push(temp)
s = stack()
s.push(444)
s.push(111)
s.push(222)
s.push(333)
s.display()
bottominsert(s,999)
s.display()
C:\test>py test.py
333
222
111
444
333
222
111
444
999
reverse stack
~~~~~~~~~~~~~
from stack import *
def reversestack(s):
if not s.isempty():
temp = s.pop()
reversestack(s)
bottominsert(s,temp)
def bottominsert(s,data):
if s.isempty():
s.push(data)
else:
temp = s.pop()
bottominsert(s,data)
s.push(temp)
s = stack()
s.push(444)
s.push(111)
s.push(222)
s.push(333)
s.display()
reversestack(s)
s.display()
C:\test>py test.py
333 222 111 444
444 111 222 333
reverse a stack by using queue
------------------------------
stack ----> LIFO
queue ----> FIFO
from queue import *
from stack import *
def reversestack(s):
q = Queue(maxsize=5)
while not s.isempty():
q.put(s.pop())
while not q.empty():
s.push(q.get())
s = stack()
s.push(111)
s.push(222)
s.push(333)
s.push(444)
s.push(555)
s.display()
reversestack(s)
s.display()
C:\test>py test.py
555 444 333 222 111
111 222 333 444 555
reverse k elements in stack
---------------------------
from queue import *
from stack import *
def reversestack(s,k):
q = Queue(maxsize=5)
i=1
while not s.isempty() and i<=k:
q.put(s.pop())
i=i+1
while not q.empty():
s.push(q.get())
s = stack()
s.push(111)
s.push(222)
s.push(333)
s.push(444)
s.push(555)
s.push(666)
s.push(777)
s.display()
reversestack(s,3)
s.display()
C:\test>py test.py
777 666 555 444 333 222 111
555 666 777 444 333 222 111
balanced parenthesis
~~~~~~~~~~~~~~~~~~~~
() True
{} True
[] True
([]) True
()[] True
([{]}) False
def balanced_parenthesis(expr):
s = []
for ch in expr:
if ch=='(' or ch=='[' or ch=='{':
s.append(ch)
elif ch==')':
if s.pop() != '(':
return False
elif ch==']':
if s.pop()!='[':
return False
elif ch=='}':
if s.pop()!='{':
return False
return len(s)==0
print(balanced_parenthesis("()")) #True
print(balanced_parenthesis("([])")) #True
print(balanced_parenthesis("([{}])")) #True
print(balanced_parenthesis("([{]})")) #False
C:\test>py test.py
True
True
True
False
Representation of expressions in programming
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
infix ----> operand operator operand
prefix ---> operator operand operand
postfix --> operand operand operator
infix prefix postfix
---------------------------------------
A+B +AB AB+
A+(B*C) +A*BC ABC*+
(A+B)*C *+ABC AB+C*
A*B+C*D +*AB*CD AB*CD*+
steps to convert infix expr into postfix form
---------------------------------------------
1) print operands in the same order they arrive.
2) if stack is empty or contains ( on top, then push incoming operator
3) if incoming symbol is ( then push into stack.
4) if incoming symbol is ) pop all items into output until ( came.
5) if the precedence of incoming symbol is >= precedence of symbol existed in the
top of stack, push that symbol into stack.
6) if the precedence of incoming symbol is < precedence of symbol existed in the
top of stack,pop the symbol from stack put it into output, then compare next symbol
else push that symbol into stack.
7) pop all symbols from stack put into output.
infix to postfix conversion implementation
------------------------------------------
def precedence(x):
if x=='(':
return 0
if x=='+' or x=='-':
return 1
if x=='*' or x=='/':
return 2
return 4
def infix_to_postfix_conversion(expn):
s = []
tokens=list(expn)
result = ""
for item in tokens:
if item in "+-*/":
while len(s)!=0 and precedence(item) <= precedence(s[-1]):
result=result+s.pop()
s.append(item)
elif item=='(':
s.append(item)
elif item==')':
temp=None
while len(s)!=0 and temp!='(':
temp = s.pop()
if temp!='(':
result = result + temp
else:
result=result+item
while len(s)!=0:
result = result + s.pop()
return result
print(infix_to_postfix_conversion("A+B")) #A
print(infix_to_postfix_conversion("A+(B*C)"))
print(infix_to_postfix_conversion("(A+B)*C)"))
print(infix_to_postfix_conversion("A*B+C*D"))
C:\test>py test.py
AB+
ABC*+
AB+C*
AB*CD*+
steps to convert infix expr into prefix form
--------------------------------------------
1) reverse the given expression
2) replace '(' with ')' and '(' with ')'
3) apply infix to postfix conversion
4) reverse generated output
infix to prefix conversion implementation
------------------------------------------
def precedence(x):
if x=='(' or x==')':
return 0
if x=='+' or x=='-':
return 1
if x=='*' or x=='/':
return 2
return 4
def infix_to_postfix_conversion(expn):
s = []
tokens=list(expn)
result = ""
for item in tokens:
if item in "+-*/":
while len(s)!=0 and precedence(item) <= precedence(s[-1]):
result=result+s.pop()
s.append(item)
elif item=='(':
s.append(item)
elif item==')':
temp=None
while len(s)!=0 and temp!='(':
temp = s.pop()
if temp!='(':
result = result + temp
else:
result=result+item
while len(s)!=0:
result = result + s.pop()
return result
def replace(expn):
s = ""
for i in expn:
if i=='(':
s=s+')'
elif i==')':
s=s+'('
else:
s=s+i
#print(s)
return s
def infix_to_prefix_conversion(expn):
expn = expn[::-1]
expn = replace(expn)
expn = infix_to_postfix_conversion(expn)
expn = expn[::-1]
return expn
print(infix_to_postfix_conversion("A+(B*C)")) #ABC*+
print(infix_to_prefix_conversion("A+(B*C)")) #+A*BC
print(infix_to_postfix_conversion("A+B")) #AB+
print(infix_to_prefix_conversion("A+B")) #+AB
print(infix_to_postfix_conversion("(A+B)*C)")) #AB+C*
print(infix_to_prefix_conversion("(A+B)*C"))#*+ABC
print(infix_to_postfix_conversion("A*B+C*D"))
print(infix_to_prefix_conversion("A*B+C*D"))
C:\test>py test.py
ABC*+
+A*BC
AB+
+AB
AB+C*
*+ABC
AB*CD*+
+*AB*CD
eval of prefix
eval of postfix
queue
8PM to 10PM
