常用排序和查找算法的原理及python实现

常用排序和查找算法的原理及python实现

常用的排序算法：冒泡排序，插入排序，归并排序,　快速排序、基数排序、堆排序，直接选择排序。

常用的查找算法：顺序查找，二分查找，哈希表查找和二叉树查找

其中我们应该重点掌握二分查找、归并排序和快速排序，保证能随时正确、完整地写出它们的代码。同时对其他的查找和排序必须能准确说出它们的特点、对其平均时间复杂度、最差时间复杂度、额外空间消耗和稳定性烂熟于胸.

算法性能总览

排序方法	最坏时间复杂度	最优时间复杂度	平均时间复杂度	空间复杂度
冒泡排序	O(n2)O(n2)	O(n)O(n)	O(n2)O(n2)	O(n)O(n),　辅助空间O(１)O(１)
插入排序	O(n2)O(n2)	O(n)O(n)	O(n2)O(n2)	O(n)O(n),　辅助空间O(１)O(１)
归并排序	O(nlogn)O(nlogn)	O(n)O(n)	O(nlogn)O(nlogn)	O(n)O(n)
快速排序	O(n2)O(n2)	O(nlogn)O(nlogn)	O(nlogn)O(nlogn)	根据实现的方式不同而不同

1. 冒泡排序

冒泡排序(Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元nn个项目需要O(n2)O(n2) 的比较次数，且可以原地排序。尽管这个算法是最简单了解和实现的排序算法之一，但它对于包含大量的元素的数列排序是很没有效率的

算法描述：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

3. 针对所有的元素重复以上的步骤，除了最后一个

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

def bubble_sort(lst):
if len(lst) <= 1:
return lst
for ind in range(len(lst)-1,0,-1):
flag = False
for sub_ind in range(ind):
if lst[sub_ind] > lst[sub_ind + 1]:
lst[sub_ind], lst[sub_ind+1] = lst[sub_ind+1], lst[sub_ind]
flag = True
if flag == False:
break
return lst

2. 插入排序

插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到 O(1)O(1) 的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间

算法描述

从第一个元素开始，该元素可以认为已经被排序

取出下一个元素，在已经排序的元素序列中从后向前扫描

如果该元素（已排序）大于新元素，将该元素移到下一位置

重复步骤3，直到找到已排序的元素小于或者等于新元素的位置

将新元素插入到该位置后

重复步骤2~5

def insertion_sort(lst):
if len(lst) == 1:
return lst

for i in range(1, len(lst)):
temp = lst[i]
j = i - 1
while j >= 0 and temp < lst[j]:
lst[j + 1] = lst[j]
j -= 1
lst[j + 1] = temp
return lst

3. 归并排序

归并排序（mergesort），是创建在归并操作上的一种有效的排序算法，效率为 O(nlogn)O(nlog⁡n)。1945年由约翰·冯·诺伊曼首次提出。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行

算法描述

迭代法

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置

3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

4. 重复步骤3直到某一指针到达序列尾

5. 将另一序列剩下的所有元素直接复制到合并序列尾

递归法

1. 将序列每相邻两个数字进行归并操作，形成 ceil(n/2)ceil(n/2) 个序列，排序后每个序列包含两/一个元素

2. 若此时序列数不是1个则将上述序列再次归并，形成 ceil(n/4)ceil(n/4) 个序列，每个序列包含四/三个元素

3. 重复步骤2，直到所有元素排序完毕，即序列数为1

def merge_sort(lst):
if len(lst) <= 1:
return lst

def merge(left, right):
merged,left,right = deque(),deque(left),deque(right)
while left and right:
merged.append(left.popleft() if left[0] <= right[0] else right.popleft())  # deque popleft is also O(1)
merged.extend(right if right else left)
return list(merged)

middle = int(len(lst) // 2)
left = merge_sort(lst[:middle])
right = merge_sort(lst[middle:])
return merge(left, right)

4. 快速排序

快速排序（Quicksort），在平均状况下，排序 nn 个项目要 O(nlogn)O(nlog⁡n)）次比较。在最坏状况下则需要 O(n2)O(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 O(nlogn)O(nlog⁡n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出

算法描述：

快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）

1. 从数列中挑出一个元素，称为”基准”（pivot）

2. 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任何一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作

3. 递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序

def quicksort(lst):
less = []
greater = []
if len(lst) <= 1:
return lst
else:
pivot = lst[-1]
for num in lst[:-1]:
if num < pivot:
less.append(num)
if num >= pivot:
greater.append(num)
return quicksort(less) + [pivot] + quicksort(greater)

in-place版本

def quicksort(lst, lo, hi):
if lo < hi:
p = partition(lst, lo, hi)
quicksort(lst, lo, p)
quicksort(lst, p+1, hi)
return

def partition(lst, lo, hi):
pivot = lst[hi-1]
i = lo - 1
for j in range(lo, hi):
if lst[j] < pivot:
i += 1
lst[i], lst[j] = lst[j], lst[i]
if lst[hi-1] < lst[i+1]:
lst[i+1], lst[hi-1] = lst[hi-1], lst[i+1]
return i+1

5. 基数排序

6. 堆排序

7. 直接选择排序

1 .顺序查找

2. 二分查找

在计算机科学中，二分搜索（binary search），是一种在有序数组中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半

算法描述

给予一个包含 nn个带值元素的数组A

1. 令 L为0 ， R为 n-1

2. 如果L>R，则搜索以失败告终

3. 令m(中间值元素)为⌊(L+R)/2⌋⌊(L+R)/2⌋

4. 如果 Am<TAm<T，令 LL为 m+1m+1 并回到步骤二

5. 如果 Am>TAm>T ，令 RR 为 m−1m−1并回到步骤二

def binary_search(arr,start,end,hkey):
if start > end:
return -1
mid = start + (end - start) / 2
if arr[mid] > hkey:
return binary_search(arr, start, mid - 1, hkey)
if arr[mid] < hkey:
return binary_search(arr, mid + 1, end, hkey)
return mid

复杂度分析

时间复杂度: 折半搜索每次把搜索区域减少一半，时间复杂度为 O(logn)O(log⁡n)

空间复杂度O(1)O(1)。虽以递归形式定义，但是尾递归，可改写为循环。

3. 哈希表查找

4. 二叉树查找