前面看到有人发了数组排序的代码,想起自己前阵子为了应付xxxxxx公司笔试复习时写下的一些关于比较排序算法 的笔记和代码,拿出来和大家分享一下,攒点RP:
(代码基本是按照《算法导论》的伪代码写的,lgn是以2为底的,西塔估计打不出,我这里都用O了)
1、Insertion Sort
遍历数组,将小的值插在前面。
是原地、 稳定 的排序算法。复杂度O(n^2)
a = [5,2,4,6,1,3]
p a
for j in 1...a.size
key = a[j]
i = j - 1
while i >=0 and a[i] > key
a[i + 1] = a[i]
i -= 1
end
a[i + 1] = key
end
p a
2、Merge Sort
递归排序A[1..n/2] A[n/2+1..n],然后合并两端已排序序列,当n=1时排序完成。
是非原地、非稳定 的排序算法。复杂度O(nlgn)
def merge (arr, s, mid, e)
n1 = mid - s + 1
n2 = e - mid
left = arr[s..mid]
right = arr[mid + 1..e]
i = j = 0
for index in s..e
if i < n1 and j < n2
if left[i] < right[j]
arr[index] = left[i]
i += 1
else
arr[index] = right[j]
j += 1
end
else
arr[index..e] = left[i...n1] if i < n1
arr[index..e] = right[j...n2] if j < n2
end
end
end
def merge_sort(arr, s, e)
if s < e
mid = (s + e) / 2
merge_sort arr, s, mid
merge_sort arr, mid + 1, e
merge arr, s, mid, e
end
end
a = [5,2,4,6,1,3]
p a
merge_sort a, 0, a.size - 1
p a
3、Quick Sort
将数组A[p..r]分成A[p..q-1]和A[q+1..r](可能有空数组),前者小于A[q],后者大于A[q];对两个数组分别进行Quick Sort。
是原地、非稳定 的排序算法,最坏运行时间O(n^2),平均运行时间O(nlgn)。
def partition arr, start_index, end_index
x = arr[end_index]
i = start_index
(start_index...end_index).each do |j|
if arr[j] <= x
arr[j], arr[i] = arr[i], arr[j]
i += 1
end
end
arr[i], arr[end_index] = arr[end_index], arr[i]
p arr
i
end
def quick_sort arr, start_index, end_index
if start_index < end_index
pivot = partition arr, start_index, end_index
quick_sort arr, start_index, pivot - 1
quick_sort arr, pivot + 1, end_index
end
end
a = [5,2,4,6,1,3]
p a
quick_sort a, 0, a.size - 1
p a
4、Heap Sort
堆可以被看作一棵完全二叉树;数组表示时,结点i,parent为[i/2],left为2i,right为2i+1;长度为n的数组表示堆, [n/2]+1到n都为叶结点。([]表示取下底)
堆排序使用最大堆,先构建最大堆,取出堆顶元素放在最后,堆的元素数减1,维护最大堆性质,再取出堆顶元素,直至完全排序。
是原地、非稳定 的排序算法,MAX_HEAPFIER时间为O(lgn),BUILD_MAX_HEAP为O(n),HEAP_SORT为O(nlogn)。
def max_heapfier arr, root_index, heap_size
left_index = root_index * 2
right_index = left_index + 1
max_index = root_index
max_index = left_index if left_index < heap_size && arr[left_index] > arr[root_index]
max_index = right_index if right_index < heap_size && arr[right_index] > arr[max_index]
unless max_index == root_index
arr[root_index], arr[max_index] = arr[max_index], arr[root_index]
max_heapfier arr, max_index, heap_size
end
end
def build_max_heap arr, root_index, heap_size
(heap_size / 2).downto(0) { |i| max_heapfier arr, i, heap_size}
end
def heap_sort arr
build_max_heap arr, 0, arr.size
heap_size = arr.size
(heap_size - 1).downto(1) do |i|
arr[0], arr[i] = arr[i], arr[0]
heap_size -= 1
max_heapfier arr, 0, heap_size
end
end
a = [5,2,4,6,1,3]
p a
heap_sort a
p a
5、Selection Sort
遍历数组,每次取出最小的元素。
是原地、稳定 的排序算法,复杂度O(n^2)。
def get_min(arr, b, e)
min_index = b
for i in b..e
min_index = i if arr[i] < arr[min_index]
end
min_index
end
a = [5,2,4,6,1,3]
p a
for i in 0...a.size
index = get_min a, i, a.size - 1
a[i], a[index] = a[index], a[i]
end
p a
6、Bubble Sort
遍历数组,邻近的两两比较,小的放前面,直到最小的移到最前面,重复这个过程,直至排序完毕。
是原地、稳定 的排序算法,复杂度O(n^2)。
a = [5,2,4,6,1,3]
def bubble_sort arr
(0...arr.size).each do |i|
(arr.size - 1).downto i do |j|
arr[j], arr[j - 1] = arr[j - 1], arr[j] if arr[j] < arr[j - 1]
end
end
end
p a
bubble_sort a
p a
(5出现在习题里,6书上没有讲,都比较简单)