more files searching and sorting

Author: arbitrarymahi

BubbleSort.py

@@ -0,0 +1,14 @@
+def bubble_sort(a_list):
+    exchanges = True
+    pass_num = len(a_list)-1
+    while pass_num > 0 and exchanges:
+        exchanges = False
+        for i  in range(pass_num):
+            if a_list[i] > a_list[i+1]:
+                exchanges = True
+                #swapping
+                a_list[i],a_list[i+1] = a_list[i+1],a_list[i]
+        pass_num -= 1
+a_list = [54,26,93,17,77,31,44,55,20,3]
+bubble_sort(a_list)
+print(a_list)

InsertionSort.py

@@ -0,0 +1,14 @@
+def insertion_sort(a_list):
+    for index in range(1,len(a_list)):
+        current_value = a_list[index]
+        position = index
+        
+        while position > 0 and current_value < a_list[position - 1]:
+            a_list[position]  = a_list[position - 1]
+            position -= 1
+        a_list[position] = current_value
+        
+a_list = [54, 26, 93, 17, 77, 31, 44, 55, 20]
+insertion_sort(a_list)
+print(a_list)    
+                    

Map.py

@@ -0,0 +1,80 @@
+class HashTable:
+    def __init__(self):
+        self.size = 11
+        self.slots = [None] * self.size
+        self.data = [None] * self.size
+        
+    def put(self, key, data):
+        hash_value = self.hash_function(key, len(self.slots))
+        
+        if self.slots[hash_value] == None:
+            self.slots[hash_value] = key
+            self.data[hash_value] = data
+        else:
+            if self.slots[hash_value] == key:
+                self.data[hash_value] = data
+            else:
+                next_slot = self.rehash(hash_value, len(self.slots))
+                                
+                while self.slots[next_slot] != None and self.slots[next_slot] != key:
+                    print(next_slot)
+                    next_slot = self.rehash(next_slot, len(self.slots))   
+                
+                if self.slots[next_slot] == None:
+                    self.slots[next_slot] = key
+                    self.data[next_slot] = data
+                else:
+                    self.data[next_slot] = data
+                    
+    def get(self, key):
+        start_slot = self.hash_function(key, len(self.slots))
+        
+        position = start_slot
+        found = False
+        stop = False
+        data = None
+        
+        while self.slots[position] != None and not found and not stop:
+            if self.slots[position] == key:
+                found = True
+                data = self.data[position]
+            else:
+                position  = self.rehash(position, len(self.slots))
+                if position == start_slot:
+                    stop = True
+        return data   
+    
+    def __getitem__(self, key):
+        return self.get(key)
+        
+    def __setitem__(self,key,data):
+        self.put(key,data)
+             
+    def hash_function(self, key, size):
+        return key % size
+        
+    def rehash(self, old_hash, size):
+        return (old_hash+1) % size
+        
+        
+        
+print("hi")        
+h=HashTable()
+h[54]="cat"
+h[20]="dog"
+h[93]="lion"
+h[17]="tiger"
+h[77]="bird"
+h[31]="cow"
+h[44]="goat"
+print("hi8")
+h[55]="pig"
+#print("hi9")
+h[26]="chicken"
+#print("hi10")
+print(h.slots)
+print(h.data)
+print(h[31])
+print(h[93])
+print(h[20])
+print(h[32])

MergeSort.py

@@ -0,0 +1,38 @@
+def merge_sort(a_list):
+    if len(a_list) > 1:
+        mid = len(a_list) // 2
+        
+        left_list = a_list[ :mid]
+        right_list = a_list[mid: ]
+        
+        merge_sort(left_list)
+        merge_sort(right_list)
+        
+        i = 0
+        j = 0
+        k = 0
+        
+        while i < len(left_list) and j < len(right_list):
+            if left_list[i] < right_list[j]:
+                a_list[k] = left_list[i]
+                i += 1
+            else:
+                a_list[k] = right_list[j]
+                j += 1
+            k += 1
+        
+        while i < len(left_list):
+            a_list[k] = left_list[i]
+            i += 1
+            k += 1
+        
+        while j < len(right_list):
+            a_list[k] = right_list[j]
+            j += 1
+            k += 1
+    print("Merging ", a_list)   
+        
+a_list = [54, 26, 93, 17, 77, 31, 44, 55, 20]
+merge_sort(a_list)
+print(a_list)
+        

QuickSort.py

@@ -0,0 +1,43 @@
+def quick_sort(a_list):
+    quick_sort_helper(a_list,0,len(a_list)-1)
+    
+def quick_sort_helper(a_list, first, last):
+    if first < last:
+        split_point = partition(a_list, first, last)
+        
+        quick_sort_helper(a_list, first, split_point-1)
+        quick_sort_helper(a_list, split_point + 1, last)  
+    
+def partition(a_list, first, last):
+    pivot_value = a_list[first]
+    
+    left_mark = first + 1
+    right_mark = last
+    
+    done = False
+    while not done:
+        while left_mark <= right_mark and \
+            a_list[left_mark] <= pivot_value:
+            left_mark += 1
+        while a_list[right_mark] >= pivot_value and \
+            right_mark >= left_mark:
+            right_mark -= 1
+            
+        if right_mark < left_mark:
+            done = True
+        else:
+            temp = a_list[left_mark]
+            a_list[left_mark] = a_list[right_mark]
+            a_list[right_mark] = temp
+            
+    temp = a_list[first]
+    a_list[first] = a_list[right_mark]
+    a_list[right_mark] = temp
+    
+    return right_mark
+    
+a_list = [54, 26, 93, 17, 77, 31, 44, 55, 20]
+quick_sort(a_list)
+print(a_list)
+            
+    

Searching_binarySearch.py

@@ -0,0 +1,19 @@
+def binary_search(a_list, item):
+    first = 0
+    last = len(a_list) - 1
+    found = False
+    
+    while first <= last and not found:
+        mid = (first + last) / 2
+        if a_list[mid] == item:
+            found = True
+        elif a_list[mid] < item:
+            first = mid +1
+        else:
+            last = mid - 1
+            
+    return found
+    
+test_list = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
+print(binary_search(test_list, 3))
+print(binary_search(test_list, 13))     

Searching_sequential.py

@@ -0,0 +1,33 @@
+def sequential_search(a_list, item):
+    pointer = 0
+    found = False
+    
+    while not found and pointer < len(a_list):
+        if item == a_list[pointer]:
+            found = True
+        else:
+            pointer += 1
+      
+    return found   
+    
+def ordered_sequential_search(a_list, item):
+    pointer = 0
+    found = False
+    stop = False
+    while not found and pointer < len(a_list) and not stop:
+        if item == a_list[pointer]:
+            found = True
+        elif item < a_list[pointer]:
+            stop = True
+        else:
+            pointer += 1
+      
+    return found    
+
+test_list = [1, 2, 32, 8, 17, 19, 42, 13, 0]
+print(sequential_search(test_list, 3))
+print(sequential_search(test_list, 13))
+
+test_list = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
+print(ordered_sequential_search(test_list, 3))
+print(ordered_sequential_search(test_list, 13))

SelectionSort.py

@@ -0,0 +1,11 @@
+def selection_sort(a_list):
+    for fill_slot in range(len(a_list) - 1, 0, -1):
+        pos_of_max = 0
+        for location in range(1, fill_slot+1):
+            if a_list[location] > a_list[pos_of_max]:
+                pos_of_max = location
+        a_list[pos_of_max], a_list[fill_slot] = a_list[fill_slot], a_list[pos_of_max]
+        
+a_list = [54, 26, 93, 17, 77, 31, 44, 55, 20,3]
+selection_sort(a_list)
+print(a_list)

ShellSort.py

@@ -0,0 +1,21 @@
+def shell_sort(a_sort):
+    sublist_count = len(a_list) // 2
+    while sublist_count > 0:
+        for start_position in range(sublist_count):
+            gap_insertion_sort(a_list, start_position, sublist_count)
+        
+        print("After increments of size ", sublist_count, "The list is ", a_list)
+
+        sublist_count = sublist_count // 2
+def gap_insertion_sort(a_list, start, gap):
+    for i in range(start+gap, len(a_list), gap):
+        current_value = a_list[i]
+        position = i
+        while position >= gap and a_list[position-gap]>current_value:
+            a_list[position] = a_list[position-gap]
+            position = position - gap
+        a_list[position] = current_value
+
+a_list = [54, 26, 93, 17, 77, 31, 44, 55, 20]
+shell_sort(a_list)
+print(a_list)

Tree_UsingListofLists.py

@@ -0,0 +1,66 @@
+def binary_tree(n):
+    return [n,[],[]]
+
+def insert_left(root,new_value):    
+    t = root.pop(1)
+    if len(t) > 1:
+        root.insert(1,[new_value,t,[]])
+    else:   
+        root.insert(1,[new_value,[],[]])
+    return root
+        
+def insert_right(root,new_value):    
+    t = root.pop(2)
+    if len(t) > 1:
+        root.insert(2,[new_value,[],t])
+    else:   
+        root.insert(2,[new_value,[],[]])
+    return root
+
+def get_root_val(root):
+    return root[0]
+
+def set_root_val(root, new_val):
+    root[0] = new_val
+    
+def get_left_child(root):
+    return root[1]
+    
+def get_right_child(root):
+    return root[2]
+    
+def build_tree():
+    x = binary_tree('a')
+    insert_left(x,'b')
+    insert_right(x,'c')
+    insert_right(get_left_child(x),'d')
+    insert_left(get_right_child(x),'e')
+    insert_right(get_right_child(x),'f')
+    return x
+
+print(build_tree())
+"""
+x = binary_tree('a')
+insert_left(x,'b')
+insert_right(x,'c')
+print x
+insert_right(get_right_child(x), 'd')
+print x
+insert_left(get_right_child(get_right_child(x)), 'e')    
+print x
+
+# another tree  
+r = binary_tree(3)
+print(r)
+insert_left(r, 4)
+insert_left(r, 5)
+insert_right(r, 6)
+insert_right(r, 7)
+print(r)
+l = get_left_child(r)
+print(l)
+set_root_val(l, 9)
+print(r)
+insert_left(l, 11)
+print(r)
+print(get_right_child(get_right_child(r)))"""