排序学习笔记（一）

排序

排序：将一组无序的记录调整为有序的记录序列。
内置排序函数：sort()

1冒泡排序

列表中每两个相邻的数进行比较，若前一个数比后一个数大，则交换这两个数。（按升序排列的情况）
一趟排序完成后，则无序区减少一个数，有序区增加一个数；一次排序一共要进行n-1趟。
易知，冒泡排序法的复杂度为O(n^2)。

import random
def bubblesort(li):
    for i in range(len(li)-1):
        exchange=False   #设定一个标志，如果在一轮循环过程中没有发生交换，则直接跳出排序过程
        for j in range(len(li)-i-1):
            if li[j]>li[j+1]:
                t=li[j]
                li[j]=li[j+1]
                li[j+1]=t
                exchange=True
        if not exchange:
            return

li=[random.randint(0,9999) for i in range(10)]
print(li)
bubblesort(li)
print(li)

2选择排序

一趟排序记录最小的数，放到第一个位置；再排序一趟，把剩下无序区最小的数放到第二个位置，以此类推。
关键：有序区和无序区、实时记录无序区最小数的位置

import random
def selectsearch(list):
    min_list=[]
    for i in range(len(list)):
        min_val=min(list)
        min_list.append(min_val)
        list.remove(min_val)
    return min_list

list=[random.randint(1,100) for i in range(10)]
print(list)
list=selectsearch(list)
print(list)

鉴于上述原理，可能会写出如上的排序算法，但是要注意该算法的复杂度是O(n^2)，因为min_val=min(list)操作的时间复杂度不是O(1)，而是O(n)。并且，该种写法还有一个不足之处在于，创建了一个新的列表，没有做到原地排序，这种做法如果在数据量很大的情况下，会浪费很多内存空间，因而可以进行优化。

def selectsearchplus(list):
    for i in range(len(list)):
        min_label=i  # 记录最小值的序号
        for j in range(i+1,len(list)):
            if list[j]<list[min_label]:
                min_label=j
        list[i],list[min_label]=list[min_label],list[i]

list=[random.randint(1,100) for i in range(10)]
print(list)
selectsearchplus(list)
print(list)

当前的排序践行了原地排序的理念，内存开销得以减小，不过时间复杂度仍然是O(n^2)。

3插入排序

列表分为有序区和无序区，每次从无序区摸一张牌插入到有序区的适当位置，循环多次，完成排序。
每次循环过程中，将该轮循环需要操作的列表元素list[i]与它前面（有序区）的元素进行比较，若前面的元素（list[i-1]）大于该元素list[i]，则进行交换；直到前面的元素比它小或者已经到达列表的首端，前面已无元素。

import random
def insertsearch(list):
    for i in range(1,len(list)):
        j=i-1
        val=list[i]
        while j>=0 and list[j]>val:
            list[j+1]=list[j]
            j=j-1
        list[j+1]=val

list=[random.randint(1,50) for i in range(12)]
print(list)
insertsearch(list)
print(list)

复杂度：O(n^2)

4快速排序

思路：取第一个元素p，将该元素进行移位，使元素可以把列表分为两个部分：左边的都比该元素p小，右边的都比该元素大。

import random

def quicksort(li,left,right):
    if left<right:
    ## 这里注意要有条件left<right，因为排序最少要在两个数中进行，这个条件可以保证这一点；否则就会出现错误： maximum recursion depth exceeded in comparison.
        mid=partition(li,left,right)
        quicksort(li,left,mid-1)
        quicksort(li,mid+1,right)

def partition(li,left,right):
    val=li[left]
    while left<right:
        while left<right and li[right]>=val:  # 从右边找比val小的，所以当li[right]>val时，继续向左循环
            right=right-1
        li[left]=li[right]
        while left<right and li[left]<=val:
            left=left+1
        li[right]=li[left]
    li[left]=val
    return left

li=[random.randint(10,99) for i in range(10)]
print(li)
quicksort(li,0,len(li)-1)
print(li)

时间复杂度的讨论：
首先关注每一层的情况，不管列表分为几个子部分，在各个部分中left和right总是会把各个子部分遍历，那么各个子部分遍历的和就是O(n)；
再看层数，进行了折半操作，故复杂度为O(logn)。因而，总的复杂度为O(nlogn)。

快速排序的问题：
1递归（涉及最大深度问题，消耗相当大的系统资源）
2可能会最坏情况
例如：

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

此种情况递归顺序：
1，8，7，6，5，4，3，2，9
1，8，7，6，5，4，3，2
2，7，6，5，4，3，8
2，7，6，5，4，3
.。。。。。。。。。。