排序算法总结

1.冒泡排序

1.1冒泡排序法

较小的数字如同气泡般慢慢浮向水面，故称为冒泡排序。

void BubbleSort(SqList *L){    int i,j;    for(i=1;i<L->Length;i++)    {        for(j=L>Length;i>=i;j--)   /*注意j是从后往前循环*/        {        if(L->r[j]>L->r[j+1])            {                swap(L,j,j+1)            }           }    }   }

1.2冒泡排序优化法

避免已经有序的情况下无意义的循环

void BubbleSort(SqList *L){    int i,j;    Status flag = TRUE;     /*用flag作为标记*/    for(i=1;i<L->Length && flag;i++)    /*若flag为true则退出循环*/    {        flag= FALSE;        for(j=L>Length;i>=i;j--)   /*注意j是从后往前循环*/        {        if(L->r[j]>L->r[j+1])            {                swap(L,j,j+1)                flag = TRUE;     /*如果有数据交换，则flag为true*/            }           }    }   }

复杂度分析：如果本身是有序的，则时间复杂度为O（n）。如果正好是逆序，则时间复杂度为O(N2)

2 简单选择排序

通过n-i次关键字的比较，从n-i+1个记录中选出关键字最小的记录，并和第i个记录交换。
该方法最大的特点是交换移动数据次数很少，这样也就节约了相应的时间，时间复杂度和冒泡一样O(N2)，但是性能上优于冒泡排序。

void SelectSort(SqList *L){    int i,j,min;    for(i=1;i<L->Length;i++)    {        min = i;        for(j=i+1;j<=L->Length;j++)        {            if(L->Lr[min]>L->r[j])                min = j;        }        if(i!=min)            swap(L,i,min);    }}

#选择排序Pythondef paixu_choose(list):    for i in range(len(list)):        smallest=list[i]        small_index=i        for j in range(i,len(list)):            if list[j]<smallest:                smallest=list[j]                small_index=j        temp = list[i]        list[i]=smallest        list[small_index]=temp    print(list)str=input()str=str.split(' ')list=[]for i in range(len(str)):    list.append(int(str[i]))list1=copy.deepcopy(list)list2 = copy.deepcopy(list)list3 = copy.deepcopy(list)list4 = copy.deepcopy(list)paixu_choose(list1)paixu_zbcr(list2)print(paixu_fast(list3))print(paixu_insert(list4))

3 直接插入排序

###Python#直接插入排序def paixu_insert(list):    if len(list)==1:        return list    for i in range(1,len(list)):        for j in range(i):            if list[i]<list[j]:                temp=list[i]                for k in range(i-1,j-1,-1):                    list[k+1]=list[k]                list[j]=temp    return list

4 折半插入排序

#折半插入排序Pythondef paixu_zbcr(list):    if len(list)<2:        return list    for i in range(1,len(list)):        left=0        right=i-1        middle = math.floor((right+left)/2)        while left<=right:            if list[i]>list[middle]:                left=middle+1            elif list[i]==list[middle]:                break            else:                right=middle-1            middle = math.floor((right + left) / 2)        temp=list[i]        for j in range(i-1,middle,-1):            list[j+1]=list[j]        list[middle+1]=temp    print(list)

5 堆排序

6 快速排序

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

void QuickSort(SqList *L){    QSort(L,1,L->Length);}

由于需要递归调用，外部封装了一个函数

void QSort(SqList){    int pivot;    if(low<high);    {        pivot = Partition(L,low,high);        QSort(L,low,pivot-1);        QSort(L,pivot+1,high);    }}

Partition函数的实现

/*交换顺序表L中子表的记录，使枢轴记录到位，并返回所在位置*//*此时在它之前（后）的记录均不大（小）与它*/int Partition(SqList *L.int low,int high){    int pivotkey;    pivotkey = L->r[low];    while(low<high);    {        while(low<high&&L->r[high]>=pivotkey)            high--;        swap(L,low,high);        while(low<high&&L->r[low]<=pivotkey)            low++;        swap(L,low,high);    }    return low;}

###Pythondef paixu_fast(list):    if len(list)<=1:        return list    ele_compare=list[0]    small_index=0    for i in range(len(list)):        if list[i]<ele_compare:            small_index=small_index+1            if small_index!=i:                temp=list[small_index]                list[small_index]=list[i]                list[i]=temp    list[0]=list[small_index]    list[small_index]=ele_compare    list_small=paixu_fast(list[:small_index])    # print(list[small_index+1:])    list_big=paixu_fast(list[small_index+1:])    return list_small+[list[small_index]]+list_big        #只能把 list与list相合并，不能把list与int相合并