插入排序 堆排序 归并排序 递归与非递归

Computer Science An Overview _J. Glenn Brookshear _11th Edition

procedure Sort (List)

N ← 2;

while (the value of N does not exceed the length of List)do

(

　　　　　　　　Select the Nth entry in List as the pivot entry;

　　　　　　　　Move the pivot entry to a temporary location leaving a hole in List;

　　　　　　　　　　while (there is a name above the hole and that name is greater than the pivot)

　　　　　　　　　　　　　　do (move the name above the hole down into the hole leaving a hole above the name)

　　　　　　　　Move the pivot entry into the hole in List;

N ← N + 1)

//pivot entry 主元项

https://baike.baidu.com/item/归并排序/1639015
https://baike.baidu.com/item/选择排序/9762418
https://baike.baidu.com/item/插入排序/7214992
https://baike.baidu.com/item/快速排序算法/369842

https://baike.baidu.com/item/冒泡排序/4602306

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

 

排序算法
平均时间复杂度
冒泡排序
O(n²)
选择排序
O(n²)
插入排序
O(n²)
希尔排序
O(n1.5)
快速排序
O(N*logN)
归并排序
O(N*logN)
堆排序
O(N*logN)
基数排序
O(d(n+r))

题目：下述几种排序方法中，要求内存最大的是（）

A、快速排序

B、插入排序

C、选择排序

D、归并排序

'''
https://baike.baidu.com/item/归并排序/1639015
https://baike.baidu.com/item/选择排序/9762418
https://baike.baidu.com/item/插入排序/7214992
https://baike.baidu.com/item/快速排序算法/369842

https://baike.baidu.com/item/冒泡排序/4602306

'''

def bubbleSort(arr):
    size=len(arr)
    if size in (0,1):
        return arr
    while size>0:
        for i in range(1,size,1):
            if arr[i-1]>arr[i]:
                arr[i-1],arr[i]=arr[i],arr[i-1] # 冒泡，交换位置
        size-=1
    return arr

for i in range(1,3,1):
    print(i)

arrs=[[],[1],[1,2],[2,1],[3,2,1]]
for i in arrs:
    print(bubbleSort(i))

'''
n-1<=C<=n(n-1)/2
'''


def quickSort(arr):
    size = len(arr)
    if size >= 2:
        mid_index = size // 2
        mid = arr[mid_index]
        left, right = [], []
        for i in range(size):
            if i == mid_index:
                continue
            num = arr[i]
            if num >= mid:
                right.append(num)
            else:
                left.append(num)
        return quickSort(left) + [mid] + quickSort(right)
    else:
        return arr


print(quickSort(arr))

'''
理想的情况是，每次划分所选择的中间数恰好将当前序列几乎等分，经过log2n趟划分，便可得到长度为1的子表。这样，整个算法的时间复杂度为O(nlog2n)。 [4] 
最坏的情况是，每次所选的中间数是当前序列中的最大或最小元素，这使得每次划分所得的子表中一个为空表，另一子表的长度为原表的长度-1。这样，长度为n的数据表的快速排序需要经过n趟划分，使得整个排序算法的时间复杂度为O(n2)。
'''


def selectSort(arr):
    '''
    TODO 优化
    '''
    ret = []
    ret_index = []
    size = len(arr)
    v = arr[0]
    for i in range(size):
        if i in ret_index:
            continue

        m = arr[i]
        if i + 1 < size:
            for j in range(i + 1, size):
                if j in ret_index:
                    continue
                n = arr[j]
                if n < m:
                    m = n
                    ret_index.append(j)
        else:
            ret_index.append(i)

        ret.append(m)
    return ret


print(selectSort(arr))


def merge(left, right):
    '''
归并操作，也叫归并算法，指的是将两个顺序序列合并成一个顺序序列的方法。
如　设有数列{6，202，100，301，38，8，1}
初始状态：6,202,100,301,38,8,1
第一次归并后：{6,202},{100,301},{8,38},{1}，比较次数：3；
第二次归并后：{6,100,202,301}，{1,8,38}，比较次数：4；
第三次归并后：{1,6,8,38,100,202,301},比较次数：4；
总的比较次数为：3+4+4=11；
逆序数为14；
    '''
    l, r, ret = 0, 0, []
    size_left, size_right = len(left), len(right)
    while l < size_left and l < size_right:
        if left[l] <= right[r]:
            ret.append(left[l])
            l += 1
        else:
            ret.append(right[r])
            r += 1
    if l < size_left:
        ret += left[l:]
    if r < size_right:
        ret += right[r:]
    return ret


def mergeSort(arr):
    size = len(arr)
    if size <= 1:
        return arr
    mid = size // 2
    left = arr[:mid]
    right = arr[mid:]
    return merge(left, right)


print(mergeSort(arr))

 

使用C语言实现12种排序方法_C 语言_脚本之家 https://www.jb51.net/article/177098.htm

Sort List （归并排序链表） - 排序链表 - 力扣（LeetCode） https://leetcode-cn.com/problems/sort-list/solution/sort-list-gui-bing-pai-xu-lian-biao-by-jyd/

 插入排序

InsertSort

l = [666,1, 45, 6, 4, 6, 7, 89, 56, 343, 3, 212, 31, 1, 44, 5, 1, 12, 34, 442]
# l =  [666, 89, 44]
print(l)
sentry = 0
for i in range(1, len(l), 1):
    if l[i] < l[i - 1]:
        sentry = l[i]
        l[i] = l[i - 1]
        j = i - 2
        while sentry < l[j] and j >= 0:
            l[j + 1] = l[j]
            j -= 1
        l[j + 1] = sentry

print(l)

希尔排序

def InsertSort(l):
    sentry = 0
    for i in range(1, len(l), 1):
        if l[i] < l[i - 1]:
            sentry = l[i]
            l[i] = l[i - 1]
            j = i - 2
            while sentry < l[j] and j >= 0:
                l[j + 1] = l[j]
                j -= 1
            l[j + 1] = sentry
    return l


def f(l, d):
    length = len(l)
    part = []
    new_l = l
    for i in range(0, length, 1):

        for j in range(i, length, d):
            part.append(l[j])
        # print("part-1",part)
        part = InsertSort(part)
        # print("part-2",part)

        for j in range(i, length, d):
            new_l[j] = part[0]
            part = part[1:]

    return new_l

l, dk = [666, 1, 45, 6, 4, 6, 7, 89, 56, 343, 3, 212, 31, 1, 44, 5, 1, 12, 34, 442], [7, 5, 3, 1]
print(l)
for i in dk:
    l = f(l, i)

print(l)