Heap Sort and DFS

Author: rusty-sj

hw3 - heap sort/hw3-report.pdf

@@ -0,0 +1,120 @@
+import random
+from time import time
+
+
+# Time Complexity: O(n log n) + O(n)
+# Space Complexity: O(log n) for recursive stack space of max_heapify
+def heap_sort(arr):
+    n = len(arr)
+    build_max_heap(arr, n)  # O(n)
+    for i in range(n - 1, 0, -1):  # delete n elements one by one from top, heapify
+        arr[i], arr[0] = arr[0], arr[i]
+        max_heapify(arr, i, 0)
+
+
+# assumes part of heap is sorted: log(n)
+def max_heapify(arr, n, i):  # log n
+    maximum = i
+    left = (2 * i) + 1
+    right = (2 * i) + 2
+    if left < n and arr[i] < arr[left]:
+        maximum = left
+    if right < n and arr[maximum] < arr[right]:
+        maximum = right
+    if maximum != i:
+        arr[i], arr[maximum] = arr[maximum], arr[i]
+        max_heapify(arr, n, maximum)
+
+
+# build max heap from unsorted array: O(n)
+def build_max_heap(arr, n):
+    for i in range(n // 2 - 1, -1, -1):
+        max_heapify(arr, n, i)
+
+
+# Time Complexity: O(n log n)
+# Space Complexity: O(log n) stack space for recursion + O(n) array after merge
+def merge_sort_recursive(numbers, low, high):
+    if low < high:
+        middle = (low + high) // 2
+        merge_sort_recursive(numbers, low, middle)
+        merge_sort_recursive(numbers, middle + 1, high)
+        merge(numbers, low, middle, high)
+
+
+def merge(numbers, low, mid, high):
+    i = low
+    j = mid + 1
+    sorted_nums = []
+    while i <= mid and j <= high:
+        if numbers[i] < numbers[j]:
+            sorted_nums.append(numbers[i])
+            i += 1
+        else:
+            sorted_nums.append(numbers[j])
+            j += 1
+
+    while i <= mid:
+        sorted_nums.append(numbers[i])
+        i += 1
+    while j <= high:
+        sorted_nums.append(numbers[j])
+        j += 1
+    numbers[low:high + 1] = sorted_nums[:]
+
+
+# Time Complexity: O(n log n); worst case O(n^2) when list is already sorted
+# Space Complexity: O(log n) stack space for recursion; O(n) stack in worst case
+def quick_sort_recursive(numbers, low, high):
+    if low >= high:
+        return
+    partition_index = partition(numbers, low, high)
+    quick_sort_recursive(numbers, low, partition_index - 1)
+    quick_sort_recursive(numbers, partition_index, high)
+
+
+def partition(numbers, low, high):
+    pivot = numbers[(low + high) // 2]  # Take middle element as pivot
+    while low <= high:
+        while numbers[low] < pivot:
+            low += 1
+        while numbers[high] > pivot:
+            high -= 1
+        if low <= high:
+            numbers[low], numbers[high] = numbers[high], numbers[low]
+            # swap(numbers, low, high)
+            low += 1
+            high -= 1
+    return low  # new partition position, every left is smaller than pivot, every right is bigger than pivot
+
+
+if __name__ == '__main__':
+    merge_time = []
+    quick_time = []
+    heap_time = []
+    xs = []
+    for x in range(100, 10100, 100):
+        xs.append(x)
+        # nums_merge = list(range(1, x + 1))
+        nums_merge = random.sample(range(1, 10100), x)
+        # print(nums_merge)
+        nums_quick = nums_merge[:]
+        nums_heap = nums_merge[:]
+
+        start_time = time()
+        merge_sort_recursive(nums_merge, 0, len(nums_merge) - 1)
+        time_taken = time() - start_time
+        merge_time.append(time_taken * 1000)
+
+        start_time = time()
+        quick_sort_recursive(nums_quick, 0, len(nums_quick) - 1)
+        time_taken = time() - start_time
+        quick_time.append(time_taken * 1000)
+
+        start_time = time()
+        heap_sort(nums_heap)
+        time_taken = time() - start_time
+        heap_time.append(time_taken * 1000)
+
+    for y in range(len(merge_time)):
+        print(xs[y], merge_time[y], quick_time[y], heap_time[y])

hw3 - heap sort/hw3.pdf

@@ -0,0 +1,46 @@
+def find_kth(list1, list2, start1, end1, start2, end2, k):
+    # Edge case 1: k greater than size of list1 + list2
+    if k > len(list1) + len(list2):
+        print("Invalid k: not in range of combined lists")
+        return -1
+
+    # Edge case 2: If list1 is exhausted, kth element is the kth in list2
+    if start1 > end1:
+        return list2[start2 + k - 1]
+
+    # Edge case 3: If list2 is exhausted, kth element is the kth in list1
+    if start2 > end2:
+        return list1[start1 + k - 1]
+
+    # Core Logic: calculate mid elements of list1 and list2
+    mid1 = (start1 + end1) // 2
+    mid2 = (start2 + end2) // 2
+
+    # if k is less than number of elements in list1[start1...mid1] and list2[start2...mid2] combined,
+    # the kth element lies in range and so we halve search space by manipulating mids, moving to right halves
+    if (mid1 - start1 + 1 + mid2 - start2 + 1) > k:
+        if list1[mid1] > list2[mid2]:  # get rid of right half of list1
+            print("computation")
+            return find_kth(list1, list2, start1, mid1 - 1, start2, end2, k)
+        else:  # get rid of right half of list2
+            print("computation")
+            return find_kth(list1, list2, start1, end1, start2, mid2 - 1, k)
+
+    # k is not within the range of combined list1[start1...mid1] and list2[start2...mid2],
+    # we shift the search space by halving lists and manipulating k
+    else:
+        if list1[mid1] > list2[mid2]:  # move to right half of list2, change k by factor of shift
+            print("computation")
+            return find_kth(list1, list2, start1, end1, mid2 + 1, end2, k - (mid2 - start2 + 1))
+        else:  # move to right half of list1, change k by factor of shift
+            print("computation")
+            return find_kth(list1, list2, mid1 + 1, end1, start2, end2, k - (mid1 - start1 + 1))
+
+
+if __name__ == '__main__':
+    array1 = [1, 3, 5, 7, 9, 11, 12]
+    array2 = [4, 5, 6]
+
+    # array1 = [10, 30, 40, 50]
+    # array2 = [30, 50, 100, 110]
+    print(find_kth(array1, array2, 0, 0, len(array1) - 1, len(array2) - 1, 2))

hw3 - heap sort/hw3.py

@@ -0,0 +1,26 @@
+def find_kth(list1, list2, k):
+    if k > len(list1) + len(list2):
+        print("k greater than combined list's length")
+        return -1
+    if not list1:
+        return list2[k - 1]
+    elif not list2:
+        return list1[k - 1]
+    elif k == 1:
+        return min(list1[0], list2[0])
+
+    mid1 = min(len(list1), k // 2)
+    mid2 = min(len(list2), k // 2)
+    print(mid1, mid2)
+    if list1[mid1 - 1] < list2[mid2 - 1]:
+        return find_kth(list1[mid1:], list2, k - mid1)
+    return find_kth(list1, list2[mid2:], k - mid2)
+
+
+if __name__ == '__main__':
+    array1 = [1, 3, 5, 7, 9, 11, 12]
+    array2 = [4, 5, 6]
+
+    # array1 = [10, 30, 40, 50]
+    # array2 = [30, 50, 100, 110]
+    print(kth_element(array1, array2, 0, 0, len(array1) - 1, len(array2) - 1, 2))

hw3 - heap sort/kth_in_two_sorted.py

@@ -0,0 +1,54 @@
+import time
+from itertools import permutations
+
+
+def e_queens(n, solutions):  # exhaustive search
+    # Generate all possible permutations representing Q1->index 0, Q2->index1, ..., Qn->index n - 1
+    for perm in permutations(range(n)):
+        if is_valid_perm(perm, n):  # Check if attack conditions are met
+            solutions.append(perm)
+
+
+def is_valid_perm(permutation, n):
+    for row_id in range(n):  # for each queen
+        for i in range(row_id):  # compare queen at row_id's placement with the other columns
+            if abs(permutation[i] - permutation[row_id]) == row_id - i:  # diagonal clash check
+                return False
+    return True
+
+
+def b_queens(row, n, placement, solutions):  # backtrack search
+    if row == n:  # when row reaches n, we have placed all the n queens without any attack conflicts
+        solutions.append(placement[:])
+    else:
+        for column in range(n):  # explore n columns for row'th queen
+            placement.append(column)
+            # print(placement)
+            if is_valid(placement):  # check if the row'th queen placed at column attacks already placed queens
+                b_queens(row + 1, n, placement, solutions)
+            placement.pop()  # done exploring column'th position
+
+
+def is_valid(placement):
+    row_id = len(placement) - 1
+    # 0 to row_id - 1 queens are placed without attack conflicts
+    for i in range(row_id):  # compare newly placed row_id'th queen with already placed queens for attacks
+        diff = abs(placement[i] - placement[row_id])
+        if diff == 0 or diff == row_id - i:  # same column clash or diagonal clash
+            return False
+    return True
+
+
+if __name__ == '__main__':
+    N = 8
+    for i in range(1, N + 1):
+        solutions_e_queens = []
+        start_e = time.time()
+        e_queens(i, solutions_e_queens)
+        e_time = (time.time() - start_e)
+
+        solutions_b_queens = []
+        start_b = time.time()
+        b_queens(0, i, [], solutions_b_queens)
+        b_time = (time.time() - start_b)
+        print("{}\t {}\t {}\t {}\t {}".format(i, len(solutions_e_queens), len(solutions_b_queens), e_time, b_time))

hw3 - heap sort/kth_in_two_sorted_logk.py

@@ -0,0 +1,33 @@
+import time
+
+
+def b_queens(row, n, placement, solutions):  # backtrack search
+    if row == n:  # when row reaches n, we have placed all the n queens without any attack conflicts
+        if is_valid(placement):
+            solutions.append(placement)
+            placement = []
+    else:
+        for column in range(n):  # explore n columns for row'th queen
+            placement.append(column)
+            print(placement)
+            b_queens(row + 1, n, placement, solutions)
+
+
+def is_valid(placement):
+    row_id = len(placement) - 1
+    # 0 to row_id - 1 queens are placed without attack conflicts
+    for i in range(row_id):  # compare newly placed row_id'th queen with already placed queens for attacks
+        diff = abs(placement[i] - placement[row_id])
+        if diff == 0 or diff == row_id - i:  # same column clash or diagonal clash
+            return False
+    return True
+
+
+if __name__ == '__main__':
+    N = 4
+    for i in range(1, N + 1):
+        solutions_b_queens = []
+        start_b = time.time()
+        b_queens(0, i, [], solutions_b_queens)
+        b_time = (time.time() - start_b)
+        print("{}\t {}\t {}".format(i, len(solutions_b_queens), b_time))