Update1: Linkedlist and Stack

Author: tusharpangare

Linked_list_functions.py

@@ -0,0 +1,189 @@
+class Node:
+    def __init__(self, data=None, next=None):
+        self.data=data
+        self.next=next
+
+class LinkedList:
+    def __init__(self):
+        self.head=None
+
+    def check_empty(self):
+        if self.head is None:
+            return True
+        return False
+
+    def insert(self, data):
+        if self.head is None:
+            self.head=Node(data, None) 
+            return
+        itr=self.head
+        while itr.next:
+            itr=itr.next
+        itr.next=Node(data, None)
+
+    def search_by_data(self, data):
+        '''here, if data is found then we'll return it's index position'''
+        if not self.head:
+            print("LL is empty, can't perform search")
+            return
+        position=0
+        itr=self.head
+        while itr:
+            if itr.data==data:
+                print(f"data present at index:{position}")   
+                break
+            position+=1
+            itr=itr.next 
+        else:
+            print("data not present") 
+
+
+    def find_ref_to_node(self, data):
+        '''here we'll find the next reference of given data'''
+        if self.head is None:
+            print("LL is empty")
+            return
+        itr=self.head
+        while itr:
+            if itr.data==data:
+                if itr.next is None:
+                    print("Current node is pointing to None") 
+                    break
+                print("Current node is pointing to:", str(itr.next.data)) 
+                return
+            itr=itr.next
+
+
+    def insert_after_given_node(self,node_data,insert_data ):
+        try:
+            assert self.head is not None
+        except AssertionError:
+            print("LL is empty")   
+        else:     
+            itr=self.head
+            while itr:
+                if itr.data == node_data:
+                    node=Node(insert_data, itr.next)
+                    itr.next=node
+                    break
+                itr=itr.next    
+    def delete_at_beginning(self):
+        if self.head is None:
+            print("LL is empty")
+            return
+        self.head=self.head.next   
+
+    def deletion_last_node(self):
+        if self.head is None:
+            print("LL is empty")
+            return
+
+        itr=self.head
+        while itr:
+            if itr.next.next is None:
+                itr.next=None
+            itr=itr.next
+             
+    def delete_node(self, data):
+        if self.head is None:
+            print("LL is empty")
+            return
+        itr=self.head
+        
+        if self.head.data==data:
+            self.head=self.head.next
+            return
+
+        while itr:
+            if itr.next is None:
+                print("value not available in the LinkedList")
+                break
+            if itr.next.data==data:
+                itr.next=itr.next.next
+                break
+            itr=itr.next
+        else:
+            print("data not founds")  
+                 
+    def find_miidle(self):
+        if self.head is None:
+            print("LL is empty")
+            return
+        slow_ptr=self.head
+        fast_ptr=self.head
+
+        while fast_ptr and fast_ptr.next:
+            # if fast_ptr.next.next is None:
+            #     print("middle of LL is", str(slow_ptr.data))
+            #     break
+            slow_ptr=slow_ptr.next
+            fast_ptr=fast_ptr.next.next    
+        print("middle of LL is", str(slow_ptr.data))   
+
+    def get_len(self):
+        if self.head is None:
+            return 0
+        itr=self.head
+        count=0
+        while itr:
+            count+=1
+            itr=itr.next
+        return count    
+
+    def reverse_LL(self):
+        current=self.head
+        prev=None
+        while current !=None:
+            temp=current.next
+            current.next=prev
+            prev=current
+            current=temp
+        self.head=prev  
+
+
+    def display_LL(self):
+        if self.head is None:
+            print("LL is empty")
+            return
+        itr=self.head
+        while itr:
+            print(itr.data,end="-->")
+            # print("%d"%(itr.data),end="-->")
+            itr=itr.next
+        print()    
+'''
+LL=LinkedList()
+LL.insert(10)                                              
+LL.insert(20)                                              
+LL.insert(30)                                              
+LL.insert(40) 
+LL.insert(50) 
+LL.insert(60) 
+LL.display_LL()   
+LL.search_by_data(30)   
+LL.find_ref_to_node(20)    
+# print(LL.find_ref_to_node.__doc__)                                   
+LL.insert_after_given_node(10, 15)
+LL.display_LL()
+LL.delete_at_beginning()
+LL.display_LL()
+LL.deletion_last_node()
+LL.display_LL()
+LL.delete_node(20)
+LL.display_LL()
+LL.find_miidle()
+print(LL.get_len())'''
+
+LL=LinkedList()
+LL.insert(10)
+LL.insert(20)
+LL.insert(30)
+LL.insert(40)
+LL.reverse_LL()
+LL.display_LL()
+
+# LL.insert(10)                                              
+# LL.insert(20)                                              
+# LL.insert(30)                                              
+# LL.insert(40) 
+# LL.find_miidle()

doubly_linked_list.py

@@ -0,0 +1,166 @@
+# for garbege collection
+import gc
+
+class Node:
+    def __init__(self, data= None, prev= None, next= None,):
+        self.data=data
+        self.next=next
+        self.prev=prev
+
+class Doubly_linked_list:
+    def __init__(self):
+        self.head=None
+
+
+    def insert_at_beginning(self, data):
+        # check if DLL is empty
+        if self.head is None:
+            # if empty insert at beginning
+            node=Node(data, None, None)
+            # now head will point to newly created node
+            self.head=node
+            return
+        # if not empty create a node pointing to current head  
+        node=Node(data,None, self.head )
+        # now hwad will be marked as newly created node bcz we're inserting at beginning
+        self.head=node
+
+    def delete_beginning(self):
+        if self.head is None:
+            print("DLL is Empty")
+            return
+        self.head=self.head.next
+        self.head.prev=None    
+
+    def delete_end(self):
+        if self.head is None:
+            print("DLL is empty")
+            return
+        itr=self.head
+        while itr.next.next:
+            itr=itr.next
+        itr.next=None             
+    
+    def insert_at_end(self, data):
+        # check if DLL is empty
+        if self.head is None:
+            # if empty insert at beginning
+            self.insert_at_beginning(data)
+            return
+        # if not empty, travese till end
+        # head will be assigned to iterator
+        itr=self.head
+        # it will iterate untill itr.next points to None i.e. it has reached end
+        while itr.next:
+            # each step, next node will be assigned to iterator
+            itr=itr.next
+
+        # we've reached att end, so we'll create a new node 
+        # whose prev will point to current last node(itr) and end will point to None
+        node=Node(data, itr, None)
+        itr.next=node
+
+    def get_len(self):
+        if self.head is None:
+            return 0
+        count=0
+        itr=self.head
+        while itr:
+            count+=1
+            itr=itr.next    
+        return count
+
+    def delete_node_by_val(self, data):
+        if self.head is None:
+            print("DLL is empty")
+            return
+        # if data present at beginning    
+        if self.head.data==data:
+            self.delete_beginning()
+            return
+
+        itr=self.head 
+        # if node is in between start and end
+        while itr.next.next:
+            if itr.next.data==data:
+                temp=itr.next.next
+                itr.next=itr.next.next
+                temp.prev=itr
+                return
+            itr=itr.next
+
+        # if node present at the end
+        if itr.next.data==data:
+            self.delete_end()
+        else:
+            print(f"node containing data {data} is not present in DLL")    
+        gc.collect()
+
+    def insert_after_node(self, node_data, insert_data):
+        if self.head is None:
+            print("DLL is empty")
+            return
+        itr=self.head
+        while itr.next:
+            if itr.data==node_data:
+                temp=itr.next
+                node=Node(insert_data, itr,itr.next)  
+                itr.next=node
+                temp.prev=node
+                break
+            itr=itr.next
+        if itr.data==node_data:
+            self.insert_at_end(insert_data)    
+        else:
+            print(f"node data {node_data} not present in DLL")    
+                    
+
+    def print_doubly_LL(self):
+        # check if empty
+        if self.head is None:
+            print("Doubly LL is empty")
+            return
+        # if not empty, iterate and print
+        itr=self.head
+        while itr:
+            print(str(itr.data),end="-->")
+            itr=itr.next
+        print()    
+
+    def print_reverse_DLL(self):
+        if self.head is None:
+            print("DLL is empty") 
+            return
+        itr=self.head
+        # here we'll get the last node
+        while itr.next:
+            itr=itr.next       
+        # we have it as our last node 
+        while itr:
+            print(str(itr.data),end="-->")
+            itr=itr.prev
+
+'''DLL=Doubly_linked_list() 
+DLL.insert_at_beginning(10)   
+DLL.insert_at_beginning(20)       
+DLL.insert_at_beginning(30)   
+DLL.insert_at_beginning(40)           
+DLL.print_doubly_LL()'''
+
+DLL=Doubly_linked_list() 
+DLL.insert_at_end(10)
+DLL.insert_at_end(20)
+DLL.insert_at_end(30)
+DLL.insert_at_end(40)
+DLL.insert_at_end(50)
+DLL.print_doubly_LL()
+DLL.insert_after_node(50, 60)
+DLL.print_doubly_LL()
+# DLL.delete_node_by_val(10)
+# DLL.print_doubly_LL()
+# DLL.print_doubly_LL()
+# DLL.delete_beginning()
+# DLL.delete_end()
+# DLL.print_doubly_LL()
+# print(DLL.get_len())
+DLL.print_reverse_DLL()