前面看到有人发了数组排序的代码,想起自己前阵子为了应付xxxxxx公司笔试复习时写下的一些关于比较排序算法 的笔记和代码,拿出来和大家分享一下,攒点RP:
(代码基本是按照《算法导论》的伪代码写的,lgn是以2为底的,西塔估计打不出,我这里都用O了)
2、Merge Sort
3、Quick Sort
4、Heap Sort
5、Selection Sort
6、Bubble Sort
(5出现在习题里,6书上没有讲,都比较简单)
(代码基本是按照《算法导论》的伪代码写的,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
递归排序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
将数组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
堆可以被看作一棵完全二叉树;数组表示时,结点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
遍历数组,每次取出最小的元素。
是原地、稳定 的排序算法,复杂度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
遍历数组,邻近的两两比较,小的放前面,直到最小的移到最前面,重复这个过程,直至排序完毕。
是原地、稳定 的排序算法,复杂度O(n^2)。
- 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
- a = [5,2,4,6,1,3]
- p a
- bubble_sort a
- p a