Essential sort and search algorihms

Author: Francesco601

ArrayStack.py

@@ -0,0 +1,45 @@
+
+class ArrayStack:
+
+    def __init__(self):
+        self.data=[]
+
+    def __len__(self):
+        return len(self.data)
+
+    def is_empty(self):
+        return len(self.data) == 0
+
+    def push(self,e):
+        self.data.append(e)
+
+    def top(self):
+        if self.is_empty():
+            return None
+        else:
+            return self.data[-1]
+
+    def pop(self):
+        if self.is_empty():
+            return None
+        else:
+            return self.data.pop()
+
+    def reverse_file(filename):
+        S=ArrayStack()
+        original = open(filename)
+        for line in original:
+            S.push(line.rstrip("\n"))
+        original.close()
+
+        output=open(filename,"w")
+        while not S.is_empty():
+            output.write(S.pop() + "\n")
+        output.close()
+
+
+
+        
+
+
+            

DoublyLinkedList.py

@@ -0,0 +1,67 @@
+
+class Node:
+    def __init__(self,data):
+        self.data=data
+        self.next=None
+        self.prev=None
+        
+class DoublyLinkedList:
+    def __init__(self):
+        self.head=None
+
+    def push(self,new_data):
+        new_node=Node(new_data)
+        new_node.next=self.head
+        if self.head is not None:
+            self.head.prev=new_node
+        self.head=new_node
+
+    def insert_after(self,prev_node,new_data):
+        if prev_node is None:
+            print("The given previous node cannot be NULL")
+            return
+        new_node=Node(new_data)
+        new_node.next=prev_node.next
+        prev_node.next=new_node
+        new_node.prev=prev_node
+        if new_node.next:
+            new_node.next.prev=new_node
+
+    def append(self,new_data):
+        new_node=Node(new_data)
+        if self.head is None:
+            self.head=new_node
+            return
+        else:
+            temp=self.head
+        while temp.next is not None:
+            temp=temp.next
+        temp.next=new_node    
+        
+
+    def print_list(self,node):
+        print("\n Traversal in forward direction.")
+        while node:
+            print(node.data,end=" ")
+            last=node
+            node=node.next
+        print("\n Traversal in reverse direction.", end=" ")
+        while last:
+            print(last.data,end=" ")
+            last=last.prev
+
+#driver code
+
+if __name__=="__main__":
+    llist=DoublyLinkedList()
+#    llist.append(6)
+    llist.push(7)
+    llist.push(1)
+#    llist.append(4)
+    llist.insert_after(llist.head.next,8)
+    print(" Created DLL is : ",end=" ")
+    llist.print_list(llist.head)
+
+    
+            
+        

LinkedQueue.py

@@ -0,0 +1,58 @@
+
+class Node:
+
+    def __init__(self,data):
+        self.data=data
+        self.next=None
+
+
+class LinkedQueue:
+
+    def __init__(self):
+        self.head=None
+        self.tail= None
+
+    def is_empty(self):
+        return self.head == None
+
+   
+    def dequeue(self):
+        if self.is_empty():
+            return None
+        else:
+            answer=self.head.data
+            self.head=self.head.next
+            if self.is_empty():
+                self.tail=None
+        return answer     
+
+    def enqueue(self,e):
+        newest=Node(e)
+        if self.is_empty():
+            self.head=newest
+            
+        else:
+            self.tail.next= newest
+        self.tail= newest    
+      
+               
+if __name__=="__main__":
+    q=LinkedQueue()
+    q.enqueue(10)
+    q.enqueue(20)
+    q.dequeue()
+    q.enqueue(30)
+    q.enqueue(40)       
+    q.enqueue(50)
+
+    q.dequeue()
+
+    print("\n Queue head: " + str(q.head.data if q.head != None else -1))
+    print("\n Queue tail: " + str(q.tail.data if q.tail != None else -1))      
+
+     
+
+            
+            
+        
+    

LinkedStack.py

@@ -0,0 +1,77 @@
+
+class Node:
+
+    def __init__(self,data):
+        self.data=data
+        self.next=None
+
+class Stack:
+
+    def __init__(self):
+        self.head=None
+
+    def is_empty(self):
+        if self.head == None:
+            return True
+        else:
+            return False
+
+    def push(self,data):
+        if self.head == None:
+            self.head = Node(data)
+        else:
+            new_node=Node(data)
+            new_node.next = self.head
+            self.head=new_node
+
+    def pop(self):
+        if self.is_empty():
+            return None
+        else:
+            popped_node=self.head
+            self.head=self.head.next
+            popped_node.next=None
+            return popped_node.data
+
+    def peek(self):
+        if self.is_empty():
+            return None
+        else:
+            return self.head.data
+
+        
+    def display(self):
+        iternode=self.head
+        if self.is_empty():
+            print("Stack Undeflow")
+        else:
+            while iternode != None:
+               print(iternode.data,end=" ")
+               iternode=iternode.next
+               if iternode != None:
+                   print("->",end=" ")
+            return      
+            
+if __name__=="__main__":
+    MyStack=Stack()
+    MyStack.push(11)
+    MyStack.push(22)
+    MyStack.push(33)       
+    MyStack.push(44)
+
+    MyStack.display()
+
+    print("\n Top element is ",MyStack.peek())
+
+    MyStack.pop()
+    MyStack.pop()
+    MyStack.display()
+
+    print("\n Top element is ",MyStack.peek())
+
+     
+
+            
+            
+        
+    

beadsort.py

@@ -0,0 +1,17 @@
+di
+
+def beadsort(input_list):
+    return_list = []
+    transposed_list= [0] * max(input_list)
+    for num in input_list:
+        transposed_list[:num] = [n + 1 for n in transposed_list[:num]]
+
+    for i in range(len(input_list)):
+        return_list.append(sum(n > i for n in transposed_list))
+
+    return  return_list
+
+input_list=[1,45,77,23,2,78,5,67,4,89]
+print(beadsort(input_list))
+
+

bin_search.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env Python3
+
+def bin_search(array,low,high,x):
+
+    if high >= low:
+
+        mid=((low+high) // 2)
+
+        if array[mid] == x:
+           return mid
+       
+        elif array[mid] > x:
+           return  bin_search(array,low,mid-1,x)
+
+        else:
+           return bin_search(array,mid+1,high,x)
+
+    else:
+        return -1
+
+
+array=[2,56,78,34,12,8,4,63,122,66,1,3,77]
+x=66
+
+
+result=bin_search(array,0,len(array)-1,x)
+
+if result != -1:
+    print("Element is present at index:", str(result))
+else:
+    print("Element is not present")
+
+
+    
+    

bin_search_iterative.py

@@ -0,0 +1,20 @@
+
+
+def bin_search_iterative(data,target):
+
+    low=0
+    high=len(data) -1
+    while low <= high:
+        mid=(low + high) // 2
+        if target == data[mid]:
+            return True
+        elif target < data[mid]:
+            high=mid - 1
+        else:
+            low=mid + 1
+    return False
+
+
+
+            
+    

bubble_sort.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env Python3
+
+from random import randint
+
+
+def bubble_sort(array):
+
+    swapped=True
+    while swapped:
+        swapped=False
+        for i in range(len(array)-1):
+            if array[i]  > array[i+1]:
+              array[i],array[i+1] = array[i+1],array[i]
+              swapped=True
+
+    
+ARRAY_LENGTH=1000
+
+array=[randint(0,1000) for i in range(ARRAY_LENGTH)]
+
+bubble_sort(array)
+
+print(array)
+