即冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、基数排序、堆排序等
一、冒泡排序
基本思想： 两个数比较大小，较大的数下沉，较小的数冒起来。
过程：
比较相邻的两个数据，如果第二个数小，就交换位置。从后向前两两比较，一直到比较最前两个数据。最终最小数被交换到起始的位置，这样第一个最小数的位置就排好了。继续重复上述过程，依次将第2.3…n-1个最小数排好位置。
python实现：
def maopao(arr):
----n = len(arr)
----for i in range(n):
--------for j in range(n-1):
------------if arr[i] < arr[j]:
--------------arr[i],arr[j] = arr[j],arr[i]
----return arr
print(“冒泡排序：”,maopao(arr))
图例：
二、选择排序
基本思想：
在长度为N的无序数组中，第一次遍历n-1个数，找到最小的数值与第一个元素交换；第二次遍历n-2个数，找到最小的数值与第二个元素交换；。。。
第n-1次遍历，找到最小的数值与第n-1个元素交换，排序完成。
python代码实现：
def xuanze(arr):
—n = len(arr)
—for i in range(n):
-------x = i
-------for j in range(i,n):
----------if arr[j] < arr[x]:
--------------x= j
-------arr[i],arr[x] = arr[x],arr[i]
—return arr
print(“选择排序：”,xuanze(arr))
图例：
三、插入排序：
基本思想：
在要排序的一组数中，假定前n-1个数已经排好序，现在将第n个数插到前面的有序数列中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。
python代码实现：
def charu(arr):
----n = len(arr)
----for i in range(n):
--------for j in range(i):
------------if arr[i]<arr[j]:
----------------arr.insert(j,arr.pop(i))
----return arr
print(“插入排序：”,charu(arr))
图例：
四、希尔排序
基本思想：
在要排序的一组数中，根据某一增量分为若干子序列，并对子序列分别进行插入排序。然后逐渐将增量减小,并重复上述过程。直至增量为1,此时数据序列基本有序,最后进行插入排序。
python代码实现：
def xier(arr):
----n = len(arr)
----while n > 1:
--------n = n//2
--------for i in range(n,len(arr)):
------------for j in range(i%n,i,n):
----------------if arr[i] <arr[j]:
--------------------arr[i],arr[j] = arr[j],arr[i]
----return arr
print(xier(arr))
图例：
五、归并排序
基本思想：
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。首先考虑下如何将2个有序数列合并。这个非常简单，只要从比较2个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。
python代码实现：
def guibing(arr):
----n = len(arr)
----if n < 2:
--------return arr
----l = n // 2
----left,right = arr[0:l],arr[l:]
----return gb(guibing(left),guibing(right))
def gb(left,right):
----soredby = []
----while left and right:
--------if left[0] < right[0]:
------------soredby.append(left.pop(0))
--------else:
------------soredby.append(right.pop(0))
----while left:
--------soredby.append(left.pop(0))
----while right:
--------soredby.append(right.pop(0))
----return soredby
print(guibing(arr))
图例：
六、快速排序
基本思想：（分治）
先从数列中取出一个数作为key值；将比这个数小的数全部放在它的左边，大于或等于它的数全部放在它的右边；对左右两个小数列重复第二步，直至各区间只有1个数。
python代码实现：
def kuaisu(arr):
----if len(arr) <= 1:
--------return arr
----p = arr[len(arr) // 2]
----left = [i for i in arr if i <p]
----middle = [i for i in arr if i == p]
----right = [i for i in arr if i > p]
----return kuaisu(left)+kuaisu(middle)+kuaisu(right)
print(kuaisu(arr))
七、基数排序
基本思想：
BinSort想法非常简单，首先创建数组A[MaxValue]；然后将每个数放到相应的位置上（例如17放在下标17的数组位置）；最后遍历数组，即为排序后的结果。
python代码实现：
def jishu(arr,d=3):
----for i in range(d):
--------s = [[] for i in range(10)]
--------for j in arr:
------------s[int(j/(10**i))%10].append(j)
--------arr = [i for b in s for i in b]
----return arr
print(jishu(arr))
图例：
八、堆排序
基本思想：
堆排序是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
python代码实现：
from collections import deque
def swap_param(L, i, j):
----L[i], L[j] = L[j], L[i]
----return L
def heap_adjust(L, start, end):
----temp = L[start]
----i = start
----j = 2 * i
----while j <= end:
--------if (j < end) and (L[j] < L[j + 1]):
------------j += 1
--------if temp < L[j]:
------------L[i] = L[j]
------------i = j
------------j = 2 * i
--------else:
------------break
----L[i] = temp
def heap_sort(L):
----L_length = len(L) - 1
----first_sort_count = L_length // 2
----for i in range(first_sort_count):
--------heap_adjust(L, first_sort_count - i, L_length)
----for i in range(L_length - 1):
--------L = swap_param(L, 1, L_length - i)
--------heap_adjust(L, 1, L_length - i - 1)
----return [L[i] for i in range(1, len(L))]
arr = deque([88,85,83,73,72,60,57,48,42,6])
arr.appendleft(0)
print(heap_sort(arr))
时间复杂度：
相关文章：