How To Implement Set In Python

Stack is a data construction which follows last in first out (LIFO) order for accessing the elements. In a stack, we tin can only access the most recently added chemical element. Stacks have many uses in applications like expression handling, backtracking and role calls. In this article, we will attempt to implement stack data construction with linked lists in python.

Implement stack in Python using linked list

A linked list is a linear data structure in which each data object points to ane another. To implement a stack with linked list, nosotros will have to perform insertion and deletion and deletion of elements from a linked list such that it takes a abiding corporeality of fourth dimension. This is only possible when we insert as well as delete the elements at the start of the linked list.

To implement a stack with linked listing in python, nosotros will first ascertain a node object which will accept the electric current chemical element, volition point to the node which was inserted only before it using a reference side by side. The Node can be implemented equally follows in python.

            form Node:     def __init__(self,data,size):         self.data=data         self.next=None

When we implement a stack with linked list, it will take an element named top which will refer to the most recent element inserted in the linked list. All other elements tin can be accessed with the help of that.We tin can implement an empty stack in python with height initialized to None and stackSize initialized to 0 as follows .

            grade Stack:     def __init__(self):         self.top=None         self.stackSize=0

Implement Push operation in stack in Python

When nosotros insert an element into the stack, the operation is called push operation. To implement push functioning in stack with the assist of linked listing, for every insertion we volition add the element to exist inserted at the start of the linked list . In this way, the nigh recent element volition e'er be at the start of the linked list. Then we will point the top chemical element of the stack to the starting time of the linked list and increment the stackSize by ane. The push operation can exist implemented using linked lists in python as follows.

                          def push(self,data):         temp=Node(data)         if self.pinnacle is None:             self.elevation=temp             cocky.stackSize= self.stackSize+1         else:             temp.next=self.peak             self.top=temp             self.stackSize=self.stackSize+i

Implement Pop operation in stack in Python

When nosotros take out an element from the stack, the functioning is said to be a pop operation. The element to exist taken out from stack is the most recently added chemical element to the stack. As we know that during a push operation, nosotros add the nigh contempo element to the start of the linked list which is pointed by the top of stack hence we volition remove the chemical element pointed by top and will point top to the adjacent recent chemical element. Before performing pop performance, we volition check if stack is empty. If the stack is empty i.east. top points to None, we will heighten an exception using python try except with a message that stack is empty. We can implement the pop performance as follows.

                          def pop(self):         attempt:             if self.top == None:                 raise Exception("Stack is Empty")             else:                 temp=cocky.acme                 self.top=self.top.side by side                 tempdata=temp.data                 self.stackSize= self.stackSize-1                 del temp                 return tempdata         except Exception as eastward:             print(str(e))

How to access topmost element of stack

As the topmost element of the stack is being referenced past top, we merely have to render the data in the node pointed past top. It can be implemented as follows.

            def top_element(self):         endeavor:             if cocky.top == None:                 raise Exception("Stack is Empty")             else:                 render self.top.data         except Exception as e:             print(str(e))

Become the size of the stack

As we go along the electric current size of stack in stackSize variable, we but accept to render the value in the stackSize variable top. This can be washed every bit follows.

            def size(self):         return cocky.stackSize

Cheque if the stack is empty

The element summit refers to the nigh recent element in the stack. If there is no element in the stack, top volition indicate to None. Thus, to cheque if the stack is empty, we just have to check if top points to None or stackSize variable has a value 0. We tin implement isEmpty() method to bank check if the stack is empty as follows.

            def isEmpty(self):         if self.stackSize==0:             return Truthful         else:             return False

The full working code to implement stack using linked list in python is every bit follows.

            #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Sun Apr 25 00:28:19 2022  @author: aditya1117 """  class Node:     def __init__(self,information):         self.data=data         self.next=None class Stack:     def __init__(cocky):         self.top=None         cocky.stackSize=0     def push button(self,information):         temp=Node(data)         if self.top is None:             self.top=temp             self.stackSize= self.stackSize+1         else:             temp.adjacent=self.acme             self.top=temp             self.stackSize=self.stackSize+i     def pop(self):         try:             if self.meridian == None:                 enhance Exception("Stack is Empty")             else:                 temp=cocky.tiptop                 self.top=self.top.side by side                 tempdata=temp.data                 self.stackSize= self.stackSize-ane                 del temp                 return tempdata         except Exception as due east:             print(str(e))     def isEmpty(cocky):         if self.stackSize==0:             return True         else:             render False     def size(cocky):         return self.stackSize     def top_element(self):         endeavour:             if self.top == None:                 raise Exception("Stack is Empty")             else:                 return self.top.information         except Exception as due east:             print(str(e)) s=Stack() s.push(1) print(southward.size())  s.push(two) print(s.size())  print(s.pop()) impress(southward.size()) print(s.pop()) print(due south.stackSize)  print(s.top_element()) print(s.isEmpty())

Output:

            1 ii 2 ane one 0 Stack is Empty None True

Determination

In this article, we have implemented stack and all its operations using linked list in python. To gain more insight into it and sympathize how stack is different from inbuilt data structures like python dictionary, list and ready , re-create the full code given in the above example and experiment with the operations in it. Stay tuned for more informative articles.

Recommended Python Training

Course: Python 3 For Beginners

Over xv hours of video content with guided instruction for beginners. Learn how to create real world applications and master the basics.