排序算法总结

来源:互联网 发布:linux mint18美化 编辑:程序博客网 时间:2024/06/16 01:26
排序类别    平均时间复杂度  最坏时间复杂度      空间复杂度  稳定性插入排序    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); }
原创粉丝点击