数据结构与算法全套精讲(python版) (五)排序

常见排序算法效率对比如下：

简述：

1. 冒泡排序：每次排序从首元素(图里为左)开始，相邻元素比较，较大者排后，直至最大数排到队尾。然后对未排序部分重复操作

2.选择排序(最易想到)：每次把未排序的部分遍历，把最小值排到该部分的首元素

3. 插入排序：先从第2个元素开始，与首元素按小到大排序。接着第3个插入到之前排好的前2个元素里。以此类推

4 .希尔排序：是插入排序的高效实现，通过对插入排序减少移动次数来实现。因为如果序列本身已基本有序，则插入排序在进行前后插入时的许多移动所需的重复操作都可以避免。总长length，初始gap 0=length / 2,  对这gap组分别做插入排序。继续如上操作gap1=gap0 / 2 (向下取整)，继续直至gap n = 1。

5.快排：先从数列中取出一个数作为基准数。分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。再对左右区间重复第二步，直到各区间只有一个数。

 

1. 冒泡排序

如下是一轮内的完整过程：每次排序从首元素(图里为左)开始，相邻元素作比较，较大者排后，直至最大的数排到队尾。然后对未排序部分重复操作

时间复杂度：

每轮操作O(n)次，共O（n）轮，时间复杂度O(n^2)

'冒泡排序'
def BubbleSort(arr):#顺序表与链表都是线性表，故都使用这几个排序方法
    n = len(arr)
    if n <= 1:
        return arr
    for i in range(n-1):#n个元素需要走n-1轮
        count = 0
        '每一轮'
        for j in range(n-1-i):  # 第i轮尚未排序的长度n-i
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                count += 1
        if 0 == count:
            return arr #若走完一轮后发现无改动，则直接结束
    return arr

arr0 = input('请输入数列，用空格隔开：\n')
arr0 = arr0.split()
arr1 = []
for k in arr0:
    # print(type(k))
    arr1.append(int(k))#输入的i如果不加int会认为是字符!
print(arr1)
print(BubbleSort(arr1))

2.  选择排序(最易想到)

简述：每次把未排序的部分遍历，把最小值排到该部分的首元素。

每轮操作O(n)次，共O（n）轮，时间复杂度O(n^2)

'选择排序'
def SelectSort(arr):
    n = len(arr)
    if n <= 1:
        return arr

    for i in range(n-1):#当前未排序部分的首元素的位置索引i
        min_index = i
        for j in range(i+1, n):
            if arr[min_index] > arr[j]:
                min_index = j
        arr[i], arr[min_index] = arr[min_index], arr[i]#把当前未排序部分的最小值排到该部分的首位
    return arr

arr0 = input('请输入数列：\n')
arr0 = arr0.split()
arr1 = []
for k in arr0:
    arr1.append(int(k))
print(arr1)
print(SelectSort(arr1))

 

3.  插入排序

简述：先从第2个元素开始，与首元素按小到大排序。接着第3个插入到之前排好的前2个元素里。以此类推

'插入排序'
def InsertSort(arr):
    n = len(arr)
    if n <= 1:
        return arr

    for i in range(1,n):#从第2个元素开始
        temp = arr[i]
        j = i
        while temp<arr[j-1] and j>0:#待插入的部分从后向前，直至遇到比temp小的
            arr[j] = arr[j-1]
            j -= 1
        arr[j] = temp
    return arr

arr0 = input('请输入数列,用空格隔开：\n')
arr0 = arr0.split()
arr1 = []
for k in arr0:
    arr1.append(int(k))
print(arr1)
print(InsertSort(arr1))

 

4 . 希尔排序

简述：是插入排序的高效实现，通过对插入排序减少移动次数来实现。因为如果序列本身已基本有序，则插入排序在进行前后插入时的许多移动所需的重复操作都可以避免。

总长length，初始gap 0=length / 2,  对这gap组分别做插入排序。继续如上操作gap1=gap0 / 2 (向下取整)，继续直至gap n = 1

def shell_sort(alist):
    n = len(alist)
    gap = n//2
    #gap变到0之前，插入算法的执行次数
    while gap > 0:
        #希尔算法，与普通插入算法的区别就是gap步长
        for j in range(gap, n):
            i = j
            while i > 0:
                if alist[i-gap] > alist[i]:
                    alist[i-gap], alist[i] = alist[i], alist[i-gap]
                    i -= gap
                else:
                    break
        #缩短步长
        gap //= 2

if __name__ == '__main__':
    li = [54,26,93,17,77,31,44,55,20]
    print(li)
    shell_sort(li)
    print(li)

5.快排

简述：先从数列中取出一个数作为基准数。分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。再对左右区间重复第二步，直到各区间只有一个数。

def quick_sort(alist,first,last):
    if first >= last:
        return
    mid_value = alist[first]
    low = first
    high = last
    while low < high:
        #high左移
        while low < high and alist[high] >= mid_value:
            high -= 1
        alist[low] = alist[high]#当mid_value的左边出现比mid_value小的值，放到alist[low]

        #low右移
        while low < high and alist[low] < mid_value:
            low += 1
        alist[high] = alist[low]#当mid_value的右边出现比mid_value大的值，放到alist[high]

    #从循环退出时，low==high
    alist[low] = mid_value
    #对low左部分做递归
    quick_sort(alist,first,low-1)
    #对low右部分做递归
    quick_sort(alist, low+1, last)

if __name__ == '__main__':
    li = [54,26,93,17,77,31,44,55,20]
    print(li)
    quick_sort(li, 0, len(li)-1)
    print(li)