排序算法总结

排序类别    平均时间复杂度  最坏时间复杂度      空间复杂度  稳定性插入排序    O(n^2)           /               1         √希尔排序    O(nlogn)      O(n^s) 1<s<2       1         ×冒泡排序    O(n^2)           /               1         √选择排序    O(n^2)           /               1         ×快速排序    O(nlogn)       O(n^2)            O(logn)   ×堆排序     O(nlogn)          /               1         ×归并排序    O(nlogn)         /               O(n)      √

排序算法总结(1)——冒泡排序

冒泡排序（属于交换排序） 时间复杂度为: O(n^2)
（1）第一种冒泡排序法：

void BubbleSort(int s[],int n)       {    int i,j,temp;    for(i=0 ; i<n-1 ; i++)    {        for(j=0 ; j<n-i-1 ; j++)  /* 按照从小到大的顺序排列 */        {            if(s[j] > s[j+1])            {                temp=s[j];                s[j]=s[j+1];                s[j+1]=temp;            }        }    }}

（2）第二种冒泡排序法：

void BubbleSort(int s[],int n)       {    int i,j,temp;    for(i=0 ; i<n-1 ; i++)    {        for(j=i+1 ; j<n ; j++)  /* 按照从小到大的顺序排列 */        {            if(s[i] > s[j])            {                temp=s[i];                s[i]=s[j];                s[j]=temp;            }        }    }}

以上两种都是一般的以交换为主要操作的冒泡排序，执行次数为:
(n-1)+(n-2)+(n-3)+……+3+2+1 = (n-1)*n/2 = (n^2 - n)/2
即时间复杂度为: O(n^2)

已排好序的冒泡排序
//对n个元素的序列进行冒泡排序时，最少的比较次数是:(n-1)。

#include <stdio.h> void main() {    int i , j ;    int a[10] = {9,8,7,6,5,4,3,2,1,0};    int len = sizeof(a)/sizeof(a[0]);    int iCount = 0 ;  //每一趟的交换次数    int sCount = 0 ;  //总共的交换次数    int nCount = 0 ;  //总共的比较次数    int temp ;    for (i = 0 ; i < len-1 ; i++)    {        iCount = 0 ;        for (j = 0 ; j < len - i -1 ; j++)        {            if (a[j+1] > a[j])            {                temp = a[j+1];                a[j+1] = a[j];                a[j] = temp ;                iCount++ ;            }            nCount++ ;        }        if (iCount == 0)        {            break ;        }        sCount = sCount + iCount ;    }    for (i = 0 ; i < len ; i++)    {        printf("%d ",a[i]);    }    printf("\n");    printf("总共的比较次数:%d\n",nCount);    printf("总共的交换次数:%d\n",sCount);  }#include <stdio.h>void main(){    int i , j ;    int a[10] = {4,8,5,6,7,4,2,2,1,0};    int len = sizeof(a)/sizeof(a[0]);    int iCount = 0 ;  //每一趟的交换次数    int sCount = 0 ;  //总共的交换次数    int nCount = 0 ;  //总共的比较次数    int temp ;    for (i = 0 ; i < len-1 ; i++)    {        iCount = 0 ;        for (j = i+1 ; j < len ; j++)        {            if (a[j] < a[i])            {                temp = a[j];                a[j] = a[i];                a[i] = temp ;                iCount++ ;            }            nCount++ ;        }        if (iCount == 0)        {            break ;        }        sCount = sCount + iCount ;    }    for (i = 0 ; i < len ; i++)    {        printf("%d ",a[i]);    }    printf("\n");    printf("总共的比较次数:%d\n",nCount);    printf("总共的交换次数:%d\n",sCount);  }

排序算法总结(2)——选择排序

每趟先从s[i]+1~s[n-1]找出最大元素或者最小元素，与s[i]进行比较、交换；
总的比较次数为: n(n-1)/2，即时间复杂度为: O(n^2)。

void SelectSort(int s[],int n)          {    int i,j,kmin,temp;    for(i=0;i<n-1;++i)    {        kmin=i;        for(j=i+1;j<n;++j)        {            if(s[j]<s[kmin])            {                kmin=j;            }        }        if(kmin!=i)        {            temp=s[i];            s[i]=s[kmin];            s[kmin]=temp;        }    }}

以上为简单的选择排序，后面还会有树形选择排序，堆排序——另一种选择排序。

排序算法总结(3)——插入排序

(一)直接插入排序

①第一种直接插入排序 时间复杂度: O(n^2)

void InsertionSort(int input[],int len) /* 按照升序排列 */{     int i,j,temp;     for (i = 1; i < len; i++)      {          temp = input[i];  /* 操作当前元素，先保存在其它变量中 */          for (j = i - 1;j>-1&&input[j] > temp ; j--) //从当前元素的上一个元素开始查找合适的位置          {               input[j + 1] = input[j]; /* 一边找一边移动元素 */               input[j] = temp;          }     }}

②第二种直接插入排序 时间复杂度: O(n^2)

void InsertSort(int s[],int n)          {    int key=0,i,j;    if(s[1]<s[0])    {        key=s[1];        s[1]=s[0];        s[0]=key;    }    for(i=2;i<n;i++)    {        if(s[i]<s[i-1])        {            key=s[i];             for(j=i-1;j>-1&&key<s[j];--j)            {                s[j+1]=s[j];            }            s[j+1]=key;     /* 比上一种好一些，执行的操作少 */        }    }}

（二）带哨兵的直接插入排序 时间复杂度: O(n^2)

/* 带哨兵的直接插入排序,数组的第一个元素不用于存储有效数据 * 将input[0]作为哨兵，可以避免判定input[j]时，数组是否越界 * 因为在j--的过程中，当j减小到0时,变成了input[0]与input[0] * 自身进行比较，很明显这个时候说明位置i之前的数字都比input[i]小 * 位置i上的数字不需要移动，直接进入下一轮的插入比较。 */

void InsertionSortWithPiquet(int input[],int len) {     int i,j;     /* 保证数组input第一元素的存储数据无效，从第二个数据开始与它前面的元素比较 */     for (i = 2; i < len; i++)      {          input[0] = input[i];          for (j = i - 1; input[j] > input[0] ; j--)           {               input[j + 1] = input[j];               input[j] = input[0];   /*  input[j]一直都是排序的元素中最大的那一个 */          }     }}

（三）折半插入（二分插入）排序 时间复杂度: O(n^2)

void HalfInsertSort(int a[], int len)   {     int i, j,temp;     int low, high, mid;     for (i=1; i<len; i++)     {          temp = a[i];/* 保存当前元素 */          low = 0;          high = i-1;          while (low <= high) /* 在a[low...high]中折半查找有序插入的位置 */          {               mid = (low + high) / 2; /* 找到中间元素 */               /* 如果中间元素比当前元素大，当前元素要插入到中间元素的左侧 */               if (a[mid] > temp)                 {                high = mid-1;               }               else /* 如果中间元素比当前元素小，当前元素要插入到中间元素的右侧 */               {                low = mid+1;               }          }       /* 找到当前元素的位置，在low和high之间 */          for (j=i-1; j>high; j--)/* 元素后移 */          {           a[j+1] = a[j];          }   /* j == high */          a[high+1] = temp; /* 插入到high后 */     }}

（四）希尔排序（ShellSort） 时间复杂度: O(nlogn)
希尔排序(Shell Sort)是插入排序的一种。是针对直接插入排序算法的改进。该方法又称缩小增量排序，因DL．Shell于1959年提出而得名。
该方法实质上是一种分组插入方法。

void sort(int v[],int n){     int gap,i,j,temp;          /*设置排序的步长，步长gap每次减半(也可以步长gap每次减2: gap -= 2)，直到减到1 */     for(gap=n/2;gap>0;gap /= 2)        {          for(i=gap;i<n;i++)  /* 定位到每一个元素 */          {               /* 比较相距gap远的两个元素的大小，根据排序方向决定如何调换 */               for(j=i-gap;(j >= 0) && (v[j] > v[j+gap]);j -= gap )                            {                temp=v[j];                v[j]=v[j+gap];                v[j+gap]=temp;               }          }     }}

后面还有 2-路插入排序、表插入排序。。

排序算法总结(4)——快速排序
平均时间复杂度: O(nlogn) 最坏时间复杂度: O(n^2)
①第一种快速排序(QuickSort) （属于交换排序）
快速排序时对冒泡排序的一种改进。由C.A.R.Hoare在1962年提出。它的长基本思想是：
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据要要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

int part(int s[],int low,int high)  {    int i = low, j = high , key = s[i] , temp ;    while (i < j)    {        while(i<j&&s[j]>=key)        {            --j;        }        if (i < j)        {            temp = s[i] ;            s[i] = s[j] ;             s[j] = temp ;           }        while (i<j&&s[i]<=key)        {            ++i;        }        if (i < j)        {            temp = s[i] ;            s[i] = s[j] ;             s[j] = temp ;           }    }    return (i);}void QuickSort(int s[],int low,int high){    if(low<high)    {        int pi=part(s,low,high);        QuickSort(s,low,pi-1);        QuickSort(s,pi+1,high);    }   }

②第二种快速排序
/*
* 首先选一个中间值，第一个元素data[low]，然后从该元素的
* 最右侧开始找到比它小的元素，把该元素复制到它中间值原来
* 的位置(data[low]=data[high])，然后从该元素的最左侧
* 开始找到比它大的元素，把该元素复制到上边刚刚找到
* 的那个元素的位置(data[high]=data[low])，最后将
* 这个刚空出来的位置装入中间值(data[low]=mid)，
* 这样一来比mid大的都会跑到mid的右侧，
* 小于mid的会在左侧，最后一行，返回的low是
* 中间元素的位置，左右分别递归就可以排好序了。
*/

int Partition(int data[],int low,int high) {    int mid=data[low];     while(low < high)     {        /* 从high的位置开始往low的方向找，找到比data[low]小的元素，存到data[low]中 */        while((low < high) && (data[high] >= mid))   {   --high;   }        if (low < high)        {               data[low]=data[high];         }         /* 从low的位置开始往high的方向找，找到比data[high]大的元素，存在data[high]中 */        while((low < high) && (data[low] < mid))    {   ++low;   }        if (low < high)        {                       data[high]=data[low];           }    }    data[low] = mid;    /* 在新的low位置 存上原来的data[low]的数据 */    return low;     /* 递归时，把它做为右侧元素的low */} 

/* n 个元素被分成三段（组）：
* 左段left,右段right和中段middle。中段仅包含一个元素。
* 左段中各元素都小于等于中段元素,右段中各元素都大于等于
* 中段元素。因此left和right中的元素可以独立排序，
* 并且不必对left和right的排序结果进行
* 合并。使用快速排序方法对a[0:n-1]
* 排序,从a[0:n-1]中选择一个元素作为middle，该元素为支点，
* 把余下的元素分割 为两段left和right，使得left中的
* 元素都小于等于支点，而right中的元素都大于
* 等于支点，递归地使用快速排序方法对left
* 进行排序,递归地使用快速排序方法对right进行排序，
* 所得结果为left+middle+right
* /

void Quick_sort(int data[],int low,int high) {    int mid;     if(low<high)     {        mid=Partition(data,low,high);         Quick_sort(data,low,mid-1); /* 递归调用 */        Quick_sort(data,mid+1,high);    } }

排序算法总结(5)——堆排序
时间复杂度: O(nlogn)
/**********************************************************
* 堆的定义: n 个元素的序列 {k1,k2,…,kn}当且仅当满足下列关系时，称为堆:
* ki<=k2i ki<=k2i+1 (i=1,2,…,n/2)
* 或
* ki>=k2i ki>=k2i+1 (i=1,2,…,n/2)
* 堆排序思路：
* 建立在树形选择排序基础上；
* 将待排序列建成堆（初始堆生成）后，序列的第一个元素（堆顶元素）就一定是序列中 的最大元素；
* 将其与序列的最后一个元素交换，将序列长度减一；
* 再将序列建成堆（堆调整）后，堆顶元素仍是序列中的最大元素，再次将其与序列最后 一个元素交换并缩短序列长度；
* 反复此过程，直至序列长度为一，所得序列即为排序后结果。
*************************************************************/

void HeapAdjust(int data[],int root,int m) /* 排列成堆的形式 */{     int j,rc;     rc = data[root];     /* 保存处理元素 */    for(j = 2*root ; j <= m ; j = 2*j)        /* 处理父亲元素 */    {        if(j < m  &&  data[j] < data[j+1])   ++j;   /* 取较大的孩子结点 */        if(rc > data[j]) break; /* 父结点比较大的孩子结点大则互换 ,保证父结点比所有子结点都大（父结点存储在前面）*/        data[root] = data[j];           root = j;     }     data[root] = rc;     /* 相当于data[j]=rc */}void Heap_sort(int data[],int len) /* 堆排序函数 */{    int i , temp;     for(i = len/2 ; i > 0 ; --i)      {        HeapAdjust(data,i,len); /* 处理后，data[i]是这个数组后半部分的最大值 */    }    for(i = len ; i > 0 ; --i)/* 把根元素（剩下元素中最大）放到结尾 ,下一次只要排剩下的数就可以啦*/    {        temp = data[1];            data[1] = data[i];         data[i] = temp;           HeapAdjust(data,1,i-1);    }}在实现时，数组下标从零开始，所以做了如下相应的改变。void HeapAdjust(int data[],int root,int m) /* 排列成堆的形式 */{     int j,rc;     rc = data[root];     /* 保存处理元素 */    for(j = 2*root+1 ; j <= m ; j = 2*j+1)        /* 处理父亲元素 */    {        if(j < m  &&  data[j] < data[j+1])  /* 取较大的孩子结点 */        {             ++j;        }        if(rc > data[j])         {            break;         }        data[root] = data[j];          root = j;     }     data[root] = rc;     /* 相当于data[j]=rc */}   void Heap_sort(int data[],int len) /* 堆排序函数 */{    int i , temp;     for(i = (len-1)/2 ; i >= 0 ; --i)      {        HeapAdjust(data,i,len-1); /* 处理后，data[i]是这个数组后半部分的最大值 */    }    for(i = len-1 ; i >= 0 ; --i)    {        temp = data[0];          data[0] = data[i];         data[i] = temp;           HeapAdjust(data,0,i-1);    }}void main(){    int len = sizeof(a)/sizeof(a[0]) ;    Heap_sort(a,len); }