算法：各种排序算法复杂度

面试官就爱这些，写不出来，基础太差，soanyway,随时都能写出来。 

1.冒泡排序,T(n) = O(n**2)

# 冒泡排序,T(n) = O(n**2)
def bubble_sort(li):
    print(li)
    for i in range(len(li)-1):  # i代表第几趟
        for j in range(len(li) - i - 1): # j代表每趟过程中的下标
            if li[j] > li[j + 1]:
                li[j], li[j +1] = li[j + 1], li[j]
        print(li)
    return li


# bubble_sort([9,8,7,6,5,4,3,2,1])

def bubble_sort(numbers):
    print('start: ', numbers)
    length = len(numbers)
    for i in range(length - 1):  # i代表第几趟
        for j in range(length - i - 1):  # j代表每趟过程中的下标
            print('length: {}-{}-{} i:{} j:{} '.format(length, length - 1, length - i - 1, i, j))
            if numbers[j] > numbers[j + 1]:
                numbers[j], numbers[j + 1] = numbers[j + 1], numbers[j]
        print('mid: ', numbers)

    print('end: ', numbers)
    return numbers

numbers = [9, 8, 6, 4, 5, 1, 3, 9, 1]
bubble_sort(numbers)
# 从小到大冒泡排序, N个数字， 要搬运N-1次， 0<=i<=length-1, 每次搬运只会搬的越来越少因此是0<=j<=(length - i - 1)

　　

2.选择排序,T(n) = O(n**2)

# 选择排序
def select_sort(li):
    for i in range(len(li)-1):
        min_index = i
        for j in range(i, len(li)):
            if li[j] < li[min_index]:
                min_index = j
        li[i],li[min_index] = li[min_index], li[i]
    return li
# print(select_sort([1,9,2,8,3,6,4,5,7]))

3.插入排序,T(n) = O(n**2)

# 插入排序,
def insert_sort(li):
    for i in range(1, len(li)):  # i代表每次摸到的牌的下标
        tmp = li[i]
        j = i - 1   # j代表手里最后一张牌的下标
        while True:
            if j < 0 or tmp >= li[j]:
                break
            li[j + 1] = li[j]
            j -= 1
        li[j + 1] = tmp

    return li

　　

lowbi3人组（冒泡，选择，插入），为什么说low，因为复杂度是O(n**2)

快堆归并nlogn

 

4.快速排序,T(n) = O(nlogn)  

java／c++ 等内置的排序算法

该方法的基本思想是：

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

关键字：分而治之， 递归

递归出口：左边的索引>=右边的索引

# 快速排序
def quick_sort(li, left, right):
    if left < right:
        mid = partition(li, left, right)
        quick_sort(li, left,  mid-1)
        quick_sort(li, mid+1, right)


def partition(data, left, right):
    tmp = data[left]
    while left < right:
        while left < right and data[right] >= tmp:
            right -= 1
        data[left] = data[right] # 第一次不满足条件时，right值固定
        while left < right and data[left] <= tmp:
            left += 1
        data[right] = data[left]
    data[left]=tmp
    return left

print(quick_sort(li, 0, len(li)-1))
print(li)

　　

 

# ! /usr/bin/env python
# -*- coding: utf-8 -*-
# __author__ = "Victor"
# Date: 2020/6/19

def quick_sort(b):
    """快速排序"""

    # 剩下1个直接返回
    if len(b) <= 1:
        return b

    mid = b[len(b) // 2]
    left, right = [], []
    b.remove(mid)

    for item in b:
        if item >= mid:
            right.append(item)
        else:
            left.append(item)

    final = quick_sort(left) + [mid] + quick_sort(right)

    return final


if __name__ == '__main__':
    b = [11, 99, 33, 69, 23, 10, 58, 91]
    final = quick_sort(b)
    print(final)

　　

 

5.堆排序,T(n) = O(nlogn)

# 堆排序
def sift(data, low, high):
    """
    调整函数
    data: 列表
    low：待调整的子树的根位置
    high：待调整的子树的最后一个节点的位置
    """
    i = low
    j = 2 * i + 1
    tmp = data[i]
    # i指向空位置
    while j<=high:      #领导已经撸到底了
        if j != high and data[j] < data[j+1]:
            j += 1
        #j指向数值大的孩子
        if tmp < data[j]:   #如果小领导比撸下来的大领导能力值大
            data[i] = data[j]
            i = j
            j = 2*i+1
        else:
            break       #撸下来的领导比候选的领导能力值大
    data[i] = tmp


def heap_sort(data):
    n = len(data)
    # 建堆
    for i in range(n//2-1, -1, -1):
        sift(data, i,  n - 1)
    # 挨个出数
    for high in range(n - 1, -1, -1):
        data[0], data[high] = data[high], data[0]
        sift(data, 0, high - 1)

　　

6.归并排序，T(n) = O(nlogn)

# 归并排序
def merge(li, low, mid, high):
    i = low
    j = mid + 1
    ltmp = []
    while i <= mid and j <= high:
        if li[i] <= li[j]:
            ltmp.append(li[i])
            i += 1
        else: # li[i]>li[j]
            ltmp.append(li[j])
            j += 1
    while i <= mid:
        ltmp.append(li[i])
        i += 1
    while j <= high:
        ltmp.append(li[j])
        j += 1
    li[low:high+1]=ltmp


def mergesort(li, low, high):
    if low < high:
        mid = (low + high) // 2
        mergesort(li, low, mid)
        mergesort(li, mid+1, high)
        merge(li, low, mid, high)

　　

7.希尔排序（O(n^(1.3—2))）

#include <stdio.h>  

// 分类 -------------- 内部比较排序
// 数据结构 ---------- 数组
// 最差时间复杂度 ---- 根据步长序列的不同而不同。已知最好的为O(n(logn)^2)
// 最优时间复杂度 ---- O(n)
// 平均时间复杂度 ---- 根据步长序列的不同而不同。
// 所需辅助空间 ------ O(1)
// 稳定性 ------------ 不稳定

void ShellSort(int A[], int n)
{
    int h = 0;
    while (h <= n)                          // 生成初始增量
    {
        h = 3 * h + 1;
    }
    while (h >= 1)
    {
        for (int i = h; i < n; i++)
        {
            int j = i - h;
            int get = A[i];
            while (j >= 0 && A[j] > get)
            {
                A[j + h] = A[j];
                j = j - h;
            }
            A[j + h] = get;
        }
        h = (h - 1) / 3;                    // 递减增量
    }
}

int main()
{
    int A[] = { 5, 2, 9, 4, 7, 6, 1, 3, 8 };// 从小到大希尔排序
    int n = sizeof(A) / sizeof(int);
    ShellSort(A, n);
    printf("希尔排序结果：");
    for (int i = 0; i < n; i++)
    {
        printf("%d ", A[i]);
    }
    printf("\n");
    return 0;
}

　　

 

 

 

 ！！！！！ 应该将原理写在这里因为经常要使用