def insertionSortSpec1():
print('Empty list')
A0 = list()
A0_result = insertionSort(A0)
assert (not bool(A0_result)), "Empty list should return empty list"
print('\n')
print('A1 = [5,2,4,6,1,3]')
A1 = [5, 2, 4, 6, 1, 3]
A1_result = insertionSort(A1)
A1_expected = [1, 2, 3, 4, 5, 6]
assert (A1_result == A1_expected), "A1"
print('\n')
print('A2 = [2,1]')
A2 = [2, 1]
A2_result = insertionSort(A2)
A2_expected = [1, 2]
assert (A2_result == A2_expected), "A2"
print('\n')
print('A3 = [0,1,2,3,4,5,6,7]')
A3 = [0, 1, 2, 3, 4, 5, 6, 7]
A3_result = insertionSort(A3)
A3_expected = [0, 1, 2, 3, 4, 5, 6, 7]
assert (A3_result == A3_expected), "A3"
print('\n')
print('A4 = [2]')
A4 = [2]
A4_result = insertionSort(A4)
A4_expected = [2]
assert (A4_result == A4_expected), "A3"
def test(self):
case_a = ['k', 'e', 'p', 'w', 'a', 'n']
case_b = [5,7,8,1,90,12,0]
insertionSort(case_a)
insertionSort(case_b)
self.assertTrue(['a', 'e', 'k', 'n', 'p', 'w'])
self.assertTrue([0, 1, 5, 7, 8, 12, 90])
def plotfunction():
sample_size = 1
x, y1, y2 = [], [], []
n = 1000
for n in range(n, n * 11, n):
A = random.sample(range(n), n)
A = insertionSort(A)
start_time = time.time()
sorted_A = insertionSort(A)
end_time = time.time()
x.append(n)
y1.append(end_time - start_time)
A = mergesort(A)
start_time = time.time()
sorted_A = mergesort(A)
end_time = time.time()
y2.append(end_time - start_time)
plt.plot(x, y1, label='Insertion')
plt.plot(x, y2, label='Merge')
plt.title("Best Case Insertion vs Merge")
plt.xlabel("Size(N)", color="blue")
plt.ylabel("Execution Time", color="blue")
plt.show()
def StartAlgorithm():
global data
scale = speedScale.get()
if not data: return
if algMenu.get() == 'Quick Sort':
quick_sort(
data,
0,
len(data) - 1,
drawData,
scale,
)
elif algMenu.get() == 'Bubble Sort':
bubbleSort(data, drawData, scale)
elif algMenu.get() == 'Selection Sort':
selectionSort(data, drawData, scale)
elif algMenu.get() == 'Merge Sort':
mergeSort(data, drawData, scale)
elif algMenu.get() == 'Insertion Sort':
insertionSort(data, drawData, scale)
drawData(data, ['green' for x in range(len(data))])
def testSort(self):
testSorted = [1, 3, 5, 6]
test1 = [1 ,3, 5, 6]
self.assertEqual(selectionSort(test1), testSorted, 0)
self.assertEqual(insertionSort(test1), testSorted, 0)
test2 = [1, 3, 6, 5]
self.assertEqual(selectionSort(test2), testSorted, 0)
self.assertEqual(insertionSort(test2), testSorted, 0)
test3 = [6, 5, 3, 1]
self.assertEqual(selectionSort(test3), testSorted, 0)
self.assertEqual(insertionSort(test3), testSorted, 0)
def test_insertion_sort(self):
A = [0, 9, 8, 3, 7, 6]
sorted_A = [0, 3, 6, 7, 8, 9]
#Tests for sorting of the list
self.assertEqual(insertionSort(A), sorted_A)
def StartAlgorithm():
global data
if not data: return
if (algMenu.get() == 'Intserion Sort'):
insertionSort(data, drawData, speedScale.get())
if (algMenu.get() == 'Bubble Sort'):
bubble_sort(data, drawData, speedScale.get())
if (algMenu.get() == 'Selection Sort'):
selectionSort(data, drawData, speedScale.get())
if (algMenu.get() == 'Merge Sort'):
merge_sort(data, drawData, speedScale.get())
if (algMenu.get() == 'Quick Sort'):
quick_sort(data, 0, len(data) - 1, drawData, speedScale.get())
drawData(data, ["green" for x in range(len(data))])
def findMedian(array):
length = len(array)
if (length < 6):
#If the length of the array is smaller than 6, then sort the array and return its median.
insertionSort(array)
return array[(length - 1) // 2]
else:
nrOfMedians = 0
medians = []
#Calculate number of medians.
if (length % 5 == 0):
nrOfMedians = length // 5
else:
nrOfMedians = length // 5 + 1
#Split the array in subarrays of maximum 5 elements and add the median.
for i in range(0, nrOfMedians):
if (i * 5 + 4 > length):
insertionSort(array[(i * 5):(length - 1)])
medians.append(array[(i * 5 + length - 1) // 2])
else:
insertionSort(array[(i * 5):(i * 5 + 4)])
medians.append(array[(10 * i + 4) // 2])
if (nrOfMedians > 5):
findMedian(medians)
return medians[(nrOfMedians - 1) // 2]
def sort(self, type="quick"):
n = len(self.lst)
for i in range(self.bucketCount):
self.bucket.append([])
for i in range(n):
self.bucket[math.floor((self.lst[i] - self.min) /
self.bucketSize)].append(self.lst[i])
m = len(self.bucket)
for i in range(m):
k = len(self.bucket[i])
if k == 1:
self.result.append(self.bucket[i][0])
continue
if k == 0:
continue
if type == "quick":
qs = QuickSort(self.bucket[i])
qs.quicksort(0, len(self.bucket[i]) - 1)
elif type == "insert":
insertionSort(self.bucket[i])
for j in range(k):
self.result.append(self.bucket[i][j])
return self.result
def quicksort_median(array, min, max):
if max - min >= 10:
pivot_index = calcMedian(array, min, max)
array[pivot_index], array[max - 1] = array[max - 1], array[pivot_index]
pivot_index = max - 1
l_index = min
r_index = max - 2
bool = True
while bool:
while array[l_index] <= array[pivot_index] and l_index <= r_index:
l_index += 1
while array[r_index] > array[pivot_index] and r_index >= l_index:
r_index -= 1
if l_index < r_index:
array[l_index], array[r_index] = array[r_index], array[l_index]
else:
bool = False
array[l_index], array[pivot_index] = array[pivot_index], array[l_index]
pivot_index = l_index
quicksort_median(array, min, l_index - 1)
quicksort_median(array, l_index + 1, max)
else:
array = insertionSort(array, min, max)
return array
def bucketSort(customList): #time - O(N^2), SPACE- O(N)
n_buckets = round(math.sqrt(len(customList)))
maxValue = max(customList)
temp_arr = []
for i in range(n_buckets):
temp_arr.append([]) #buckets
for j in customList:
indexOfBucket = math.ceil(j * n_buckets / maxValue)
#inserts element in appropriate bucket, starting from 0th index
temp_arr[indexOfBucket - 1].append(j)
for i in range(n_buckets):
temp_arr[i] = insertionSort(temp_arr[i])
#merge sorted buckets
k = 0
for i in range(n_buckets):
for j in range(len(temp_arr[i])):
customList[k] = temp_arr[i][j]
k += 1
return customList
if __name__ == "__main__":
time_start = time.time()
nums = RandomArray()
nums = MergeSort(nums)
time_end = time.time()
print('totally cost', time_end - time_start)
a = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
a = MergeSort(a)
for w in a:
print(w)
# for w in nums:
# print(w)
time_start = time.time()
nums = NearlyOrderArray(swap_times=0, number=50000)
nums = MergeSort(nums)
time_end = time.time()
print('Merge sort totally cost', time_end - time_start)
time_start = time.time()
nums = NearlyOrderArray(swap_times=0, number=10000)
nums = insertionSort(nums)
time_end = time.time()
print('Insertion sort totally cost', time_end - time_start)
def test_already_sorted(self):
input = [0, 1, 2, 3, 4, 5]
self.assertEqual(insertionSort(input), sorted(input),
"Should be [0,1,2,3,4,5]")
def test_backwards_array(self):
input = [5, 4, 3, 2, 1]
self.assertEqual(insertionSort(input), sorted(input),
"Should be [1, 2, 3, 4, 5]")
def test_unsorted_array(self):
input = [1, 5, 63, 3, 54, 1]
self.assertEqual(insertionSort(input), sorted(input),
"Should be [1, 1, 3, 5, 54, 63]")
def test_empty_array(self):
input = []
self.assertEqual(insertionSort(input), sorted(input), "Should be []")
data.append(int(line))
if sort_fun == 'merge':
start = time.time()
mergeSort(data)
total = time.time() - start
elif sort_fun == 'quick':
start = time.time()
quickSort(data, 0, len(data)-1)
total = time.time() - start
elif sort_fun == 'heap':
start = time.time()
heapSort(data)
total = time.time() - start
elif sort_fun == 'insertion':
start = time.time()
insertionSort(data)
total = time.time() - start
else:
print("please input correct method!!!")
for k in range(0, n-1):
if data[k] > data[k+1]:
print("error!")
break
print("correct!")
print("Sorting Time : %dms" % float(1000*total))
# 開啟檔案
wb = openpyxl.load_workbook(u'./HW1/學號_HW1_report.xlsx')
# 設定目前工作的工作表
ws = wb[sort_fun+' sort result']
row = dict_n[n] + str(i + 1)
ws[row] = str(math.floor(1000 * total)) + ' ms'
from InsertionSort import insertionSort
assert (insertionSort([]) == [])
assert (insertionSort([3]) == [3])
assert (insertionSort([8, 3]) == [3, 8])
assert (insertionSort([3, 8, 2, 7, 3, 2, 5, 3]) == [2, 2, 3, 3, 3, 5, 7, 8])
assert (insertionSort([3, 8, 5, 6, 7, 1, 2, 9, 2, 3, 7,
5]) == [1, 2, 2, 3, 3, 5, 5, 6, 7, 7, 8, 9])
def sort(l):
limit = 30
if len(l) < 30:
insertionSort(l)
else:
quickSort(l)
from QuickSort_Median import quicksort_median
setrecursionlimit(100000)
n = int(input("Enter the number of elements to be sorted: "))
#Generate random numbers for the given number of elements
content = []
for x in range(n):
content.append(random.randint(1, int(0.95 * n)))
#Perform insertion sort and take average time by running it thrice
avgTimeArray = []
for x in range(3):
input1 = copy.deepcopy(content)
start = time.time()
result = insertionSort(input1, 0, len(content) - 1)
end = time.time()
timeElapsed = end - start
avgTimeArray.append(timeElapsed)
temp = 0.0
for x in range(3):
temp += avgTimeArray[x]
avgTime = temp / 3
print("Execution time for Insertion Sort is:", avgTime)
#Perform merge sort and take average time by running it thrice
avgTimeArray = []
for x in range(3):
input2 = copy.deepcopy(content)
start = time.time()
result = mergeSort(input2)
from BubbleSort import bubbleSort
from SelectionSort import selectionSort
from InsertionSort import insertionSort
toBeSortedList = [3, 2, 6, 8, 6, 4, 9, 5]
print(f"Unsorted list \n {toBeSortedList}")
sortedList = insertionSort(toBeSortedList)
print(f"Sorted list \n {sortedList}")
