How to Read From Deque Without Popping

Data structures play a key role in the programming world. They help u.s. to organize our data in a fashion that tin be used efficiently. The stack is 1 of the simplest information structures.

Let's acquire nearly the stack and its implementation in Python.

What is a Stack?

A stack is like to the pile of books, chairs, etc.., in real-life. And it follows the Last-in/First-out (LIFO) principle. It is the simplest data structure. Let'southward see the scenario with a real-world case.

Permit's say we have a pile of books as follows.

When nosotros desire the third book from the summit then, we have to remove the first two books from the top to accept out the tertiary book. Here, the topmost book goes terminal to the pile and comes outset of the pile. The data structure stack follows the same principle Last-in/Starting time-out (LIFO) in programming.

Operations in Stack

At that place are mainly ii operations in a stack

1. push(data)

Adds or pushes the data into the stack.

two. popular()

Removes or pops the topmost element from the stack.

Come across the beneath illustrations of push and pop operations.

We will write some helper functions that help us to get more than info about the stack.

Let's see them.

peek()

Returns the topmost element from the stack.

is_empty()

Returns whether the stack is empty or not.

Plenty conceptual aspects of the stack data construction. Let's jump into the implementation without further ado.

I presume y'all accept python installed on your PC if not you can also try the online compiler.

Stack Implementation

Implementing stack is the easiest one compared to other data construction implementations. We tin implement a stack in multiple ways in Python.

Allow's run across all of them ane past one.

#1. Listing

Nosotros are going to implement the stack using the listing in a class. Permit'due south see the step by stride implementation of the stack.

Step1: Write a class chosen Stack.

          course Stack: 	pass        

Step2: We have to maintain the information in a listing. Let's add an empty listing in the Stack form with name elements.

          class Stack: 	def __init__(self): 		self.elements = []        

Step3: To push the elements into the stack, we need a method. Let's write a push method that takes data equally an argument and suspend it to the elements list.

          class Stack: 	def __init__(self): 		self.elements = []  	def push(self, data): 		self.elements.append(data) 		return information        

Step4: Similarly, let'due south write the popular method that pops out the topmost element from the stack. We tin use the popular method of the list information type.

          class Stack: 	## ... 	def pop(self): 		return cocky.elements.pop()        

We have completed the stack implementation with the required operations. Now, let's add the helper functions to get more info about the stack.

Step5: We can get the topmost chemical element from the stack using the negative alphabetize. The code <bridge data-token-index="ii" data-reactroot="">chemical element[-1]</span> returns the last of the list. Information technology is the topmost chemical element of the stack in our instance.

          class Stack: 	## ...  	def peek(self): 		return self.elements[-1]        

Step6: If the length of the elements list is 0, and then the stack is empty. Let's write a method that returns whether the element is empty or non.

          class Stack: 	## ... 	def is_empty(self): 		return len(self.elements) == 0        

We accept completed implementing the stack using the listing information type.

Oh! await we but implemented it. Just, didn't run into how to utilise information technology. How to utilise it then?

Come up allow's see how to implement it. We take to create an object for the Stack course to use information technology. It's not a large deal. Let's do it first.

          class Stack:      ## ...  if __name__ == '__main__':     stack = Stack()        

Nosotros have created the stack object and fix to employ it. Allow's follow the beneath steps to exam stack operations.

• Check whether the stack is empty or not using the is_empty method. Information technology should return True.
• Push the numbers i, 2, three, 4, five into the stack using the button method.
• The is_empty method should render Faux. Check it.
• Print the topmost element using the peek method.
• Pop the element from the stack using the pop method.
• Check the peek element. It should return the element 4.
• Now, pop all the elements from the stack.
• The is_empty method should render True. Check it.

Our stack implementation is completed if it passes all the above steps. Endeavor to write the code for the above steps.

Did yous write the lawmaking? No, don't worry check the lawmaking below.

          class Stack:      def __init__(cocky):          cocky.elements = []           def button(self, data):          self.elements.suspend(data)          return data           def popular(self):          render self.elements.pop()               def peek(cocky):          return cocky.elements[-1]               def is_empty(self):          return len(self.elements) == 0  if __name__ == '__main__':     stack = Stack()          ## checking is_empty method -> true     impress(stack.is_empty())      ## pushing the elements     stack.push button(ane)     stack.push button(2)     stack.button(3)     stack.push button(four)     stack.push(five)      ## once more checking is_empty method -> fake     print(stack.is_empty())      ## press the topmost element of the stack -> 5     impress(stack.peek())      ## popping the topmost element -> v     stack.pop()      ## checking the topmost element using peek method -> four     print(stack.peek())      ## popping all the elements     stack.popular()     stack.pop()      stack.pop()      stack.pop()       ## checking the is_empty method for the final time -> true     print(stack.is_empty())                  

Hurray! we have completed the stack implementation from scratch using the list data type. You will see the output every bit mentioned below if you run the above code.

          Truthful False 5 four True        

We can directly employ the list data type as a stack. The above implementation of stack helps y'all empathize the stack implementation in other programming languages besides.

You can also check out these listing related articles.

• Check if the list is Empty
• Flatten listing
• Convert list to dictionary

Permit'south run into the born deque from the collections built-in module which can act as a stack.

#2. deque from collections

Information technology is implemented equally a double-ended queue. Since information technology supports the addition and removal of elements from both ends. Hence we can apply it as a stack. We can make information technology follow the LIFO principle of the stack.

It is implemented using other data structures chosen the doubly-linked list. And then the performance of the insertion and deletion of elements are consistent. Accessing elements from the middle linked list took O(n) time. We can use it equally a stack as there is no need to access the middle elements from the stack.

Before implementing the stack, let's encounter the methods that are used to implement the stack using the queue.

• suspend(data) – used to push the data to the stack
• pop() – used to remove the topmost element from the stack

There are no alternative methods for peek and is_empty. Nosotros tin print the whole stack in identify of peek method. Adjacent, we can apply the len method to bank check whether the stack is empty or not.

Let's implement the stack using deque from the collections module.

          from collections import deque  ## creating deque object stack = deque()  ## checking whether stack is empty or non -> truthful impress(len(stack) == 0)  ## pushing the elements stack.append(1) stack.suspend(2) stack.suspend(3) stack.append(4) stack.suspend(5)  ## again checking whether stack is empty or non -> faux print(len(stack) == 0)  ## printing the stack print(stack)  ## popping the topmost element -> v stack.pop()  ## printing the stack print(stack)  ## popping all the elements stack.pop() stack.popular()  stack.popular()  stack.pop()   ## checking the whether stack is empty or not for the final time -> truthful impress(len(stack) == 0)        

That'due south it. We have learned how to implement stack using the deque from the collections built-in module. You lot will get the output as mentioned beneath if you lot execute the above plan.

          True False deque([i, 2, 3, 4, v]) deque([one, ii, 3, 4]) True        

Till at present, we have seen 2 means to implement the stack. Are there any other ways to implement a stack? Yeah! Let's meet the concluding way to implement a stack in this tutorial.

#3. LifoQueue

The nameLifoQueue itself says that it follows the LIFO principle. Hence we tin can use it as a stack without any doubt. It is from the built-in module queue. The LifoQueue provides some handy methods that are useful in the stack implementation. Let's see them

• put(data) – adds or pushes the data to the queue
• go() – removes or pops the topmost element from the queue
• empty() – returns whether the stack is empty or non
• qsize() – returns the length of the queue

Permit's implement the stack using LifoQueue from thequeue module.

          from queue import LifoQueue  ## creating LifoQueue object stack = LifoQueue()  ## checking whether stack is empty or not -> true print(stack.empty())  ## pushing the elements stack.put(1) stack.put(2) stack.put(3) stack.put(4) stack.put(5)  ## again checking whether stack is empty or not -> fake impress(stack.empty())  ## popping all the elements print(stack.get()) impress(stack.get()) impress(stack.become())  ## checking the stack size print("Size", stack.qsize())  print(stack.get()) print(stack.get())  ## checking the whether stack is empty or not for the terminal time -> true print(stack.empty())                  

You volition get the output mentioned below if yous execute the above program without changing information technology.

          True False 5 iv three Size ii two 1 True        

Application of Stack

Now, y'all have sufficient knowledge almost stacks to employ information technology in programming problems. Let'south run into a problem and solve it using a stack.

Given an expression, write a program to check whether the parentheses, braces, curly-braces are balanced correctly or not.

Let's run into some examples.

Input: "[{}]([])"

Output: Counterbalanced

Input: "{[}]([])"

Output: Not Balanced

We tin use the stack to solve the in a higher place trouble. Allow'south come across the steps to solve the problem.

• Create a stack to store the characters.
• If the length of the expression is odd, then the expression is Not Balanced
• Iterate through the given expression.
  • If the current character is the opening subclass from ( or { or [, and so push information technology to stack.
  • Else if the electric current graphic symbol is a closing bracket ) or } or ], then pop from the stack.
  • If the popped character is matching with the starting bracket and so go along else brackets are non balanced.
• Subsequently the iteration, if the stack is empty then the equation is Balanced else the equation is Not Balanced.

Nosotros can make employ of the gear up information type for brackets friction match checking.

          ## stack class Stack:      def __init__(cocky):          self.elements = []           def push(self, data):          self.elements.suspend(information)          return data               def pop(self):          return self.elements.pop()           def peek(cocky):          render self.elements[-1]               def is_empty(self):          return len(self.elements) == 0  def balance_check(expression):     ## checking the length of the expression     if len(expression) % 2 != 0:         ## not balanced if the length is odd         return False          ## for checking     opening_brackets = set('([{')      pairs = set([ ('(',')'), ('[',']'), ('{','}') ])           ## stack initialization     stack = Stack()          ## iterating through the given expression     for subclass in expression:          ## checking whether the electric current bracket is opened or not                 if bracket in opening_brackets:             ## calculation to the stack              stack.push(bracket)         else:             ## popping out the concluding bracket from the stack             popped_bracket = stack.popular()                      ## checking whether popped and electric current bracket pair             if (popped_bracket, bracket) not in pairs:                 return False          return stack.is_empty()  if __name__ == '__main__':     if balance_check('[{}]([])'):         impress("Balanced")     else:         print("Not Counterbalanced")          if balance_check('{[}]([])'):         print("Balanced")     else:         impress("Not Counterbalanced")        

We can use the stack to solve many more issues. The above problem is one of them. Try to use the stack concept wherever y'all remember it best suits you.

Determination

Yah! You lot take completed the tutorial. I hope yous enjoyed the tutorial as much as I do while making information technology. That's it for the tutorial.

Happy Coding 🙂 👨‍💻

nobleswhould46.blogspot.com

Source: https://geekflare.com/python-stack-implementation/

Share this post