选择插入冒泡归并快速排序

时间复杂度

选择排序

选择排序(Selection-sort)是一种简单直观的排序算法。

它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 

表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。

def selectSort(list):
    for i in range(len(list)):
        temp = i
        for j in range(i+1,len(list)):
            if list[temp]>list[j]:
                temp=j
        swap(list,i,temp)

插入排序

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

• 从第一个元素开始，该元素可以认为已经被排序；
• 取出下一个元素，在已经排序的元素序列中从后向前扫描；
• 如果该元素（已排序）大于新元素，将该元素移到下一位置；
• 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
• 将新元素插入到该位置后；
• 重复步骤2~5。

def insertSort(list):
    for i in range(1,len(list)):
        temp=list[i]
        index=i
        for j in range(i,0,-1):
            if temp<list[j-1]:
                list[j]=list[j-1]
                index=j-1
            else:
                break
        list[index]=temp

 

冒泡排序

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。

• 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
• 针对所有的元素重复以上的步骤，除了最后一个；
• 重复步骤1~3，直到不发生交换，排序完成。

优化：记录最后一个发生交换的位置，后面的都已经有序，下次只需要遍历到这一步就可以。

def bubbleSort(list):
    n = len(list)
    newn = n
    while(newn>0):
        newn=0
        for i in range(1,n):
           if list[i]<list[i-1]:
               swap(list,i,i-1)
               newn=i
        n = newn

 

归并排序

归并排序是建立在归并操作上的一种有效的排序算法。

算法过程：该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并

def merge(left, right):
    c = []
    l = r =0
    while l<len(left) and r<len(right):
        if left[l]<right[r]:
            c.append(left[l])
            l+=1
        else:
            c.append(right[r])
            r+=1
    if l==len(left):
        for i in right[r:]:
            c.append(i)
    else:
        for i in left[l:]:
            c.append(i)
    return c


def merge_sort(list):
    if len(list)<=1:
        return list
    mid = len(list)/2
    left = merge_sort(list[:mid])
    right = merge_sort(list[mid:])
    return merge(left,right)

归并排序是一种稳定的排序方法。和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(nlogn）的时间复杂度。代价是需要额外的内存空间。

 

快速排序

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

• 从数列中挑出一个元素，称为 “基准”（pivot）；
• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

 

def sub_sort(array,low,high):
    key = array[low]
    while low<high:
        while low<high and array[high]>=key:
            high-=1
        while low<high and array[high]<key:
            array[low]=array[high]
            low+=1
            array[high]=array[low]
    array[low]=key
    return low


def quickSort(array,low,high):
    if low<high:
        key = sub_sort(array,low,high)
        quickSort(array,low,key)
        quickSort(array,key+1,high)

对于近乎有序的排序插入甚至比nlogn还要好，

 

希尔排序 n（3/2）