数据结构和算法（2）

一.排序进阶

1.快速排序
快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
快速排序步骤:

• 从数列中挑出一个元素，称为"基准"（pivot），
• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
  时间复杂度:
• 最优时间复杂度：O(nlogn)
• 最坏时间复杂度：O(n2)
• 稳定性：不稳定

def partition(li,left,right):
    tmp=li[left]

    while left<right:
        while left<right and li[right]>=tmp:
             right=right-1
        li[left]=li[right]

        while left<right and li[left]<=tmp:
            left=left+1
        li[right]=li[left]

    li[left]=tmp
    return left

def quick_sort(li,left,right):
    if left<right:
        mid=partition(li,left,right)
        quick_sort(li,left,mid)
        quick_sort(li,mid+1,right)

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

2.归并排序
归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组。

将数组分解最小之后，然后合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。
时间复杂度

• 最优时间复杂度：O(nlogn)
• 最坏时间复杂度：O(nlogn)
• 稳定性：稳定

li = [10, 4, 6, 3, 8, 2, 5, 7]


def merge(li, low, mid, high):  #high=7
    i=low
    j=mid+1
    tmp=[]
    while i<=mid and j<=high:
        if li[i]<=li[j]:
            tmp.append(li[i])
            i=i+1
        else:
            tmp.append(li[j])
            j=j+1
    while i<=mid:
        tmp.append(li[i])
        i=i+1
    while j<=high:
        tmp.append(li[j])
        j=j+1
    li[low:high+1]=tmp


def merge_sort(li, low, high):
    if low < high:
        mid = (low + high) // 2
        merge_sort(li, low, mid)
        merge_sort(li, mid + 1, high)
        print("归并之前:",li[low:high+1])
        merge(li,low,mid,high)
        print("归并之后:", li[low:high + 1])

merge_sort(li,0,len(li)-1)

3.希尔排序