基本排序算法

最新推荐文章于 2022-03-29 14:25:38 发布

皮小猪的时光

最新推荐文章于 2022-03-29 14:25:38 发布

阅读量574

点赞数

分类专栏：数据结构文章标签：排序算法冒泡排序希尔排序插入排序选择排序

本文链接：https://blog.csdn.net/hihozoo/article/details/51316337

版权

数据结构专栏收录该内容

12 篇文章 0 订阅

订阅专栏

以下是四种基本的排序算法

算法	平均情况	最好情况	最坏情况	稳定性
冒泡排序	O(n^2)	O(n)	O(n^2)	稳定
选择排序	O(n^2)	O(n^2)	O(n^2)	不稳定
插入排序	O(n^2)	O(n)	O(n^2)	稳定
希尔排序	O(nlogn ~ n^2)	O(n^1.3)	O(n^2)	不稳定

STL 算法中也提供高效的排序算法，可参考 STL 排序算法

一、冒泡排序

冒泡排序是一种简单直观的排序算法。它重复地走访要排序的数列，每次比较两两相邻的两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。交换的目的是要把最小或者最大的值放到未排序数列部分的尾部。

1.1 算法步骤

比较相邻的元素。如果第一个比第二个大（小），就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数（或者最小的）。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

时间复杂度：

平均，O(n^2)
最好，O(n)：根据以下优化的版本，如果序列已排序，则循环一次就将退出，此时时间复杂度为O（n）
最差，O(n^2)

void bubble_sort(int arr[],int n) // n：数组大小
{
   for(int i = 0; i < n-1 ; i++)
   {
      for(int j = 0 ; j+1 <= n-1-i ; j++)
      {
          if( arr[j] < arr[j+1] )
              swap(arr[j],arr[j+1]);
      }
   }
}

1.2 优化

针对上述代码，有两种优化方案：

优化1：某一趟遍历如果没有数据交换，则说明已经排好序了，因此不用再进行迭代了。用一个标记记录这个状态即可。
优化2：记录某次遍历时最后发生数据交换的位置，这个位置之后的数据显然已经有序，不用再排序了。因此通过记录最后发生数据交换的位置就可以确定下次循环的范围了。

优化方案1：

void bubble_sort(int arr[],int n)

{ //冒泡排序
   int flag = 0; //用于标记是否发生数据交换
   int i,j;
   for(i = 0; i < n-1 ; i++)
   {
      for(j = 0 ; j+1 <= n-1-i ; j++)
      {
          if( arr[j] < arr[j+1] )
          {
              swap(arr[j],arr[j+1]);
              flag = 1; // 1:表示发生了数据交换
          }
      }
      if( flag == 0 )//为0,表示此轮比较没有发生数据交换，即表明已经排序好了
          break;
      else
          flag = 0; //此轮有发生数据交换，测试下一轮之前初始化flag标志
   }
}

优化方案2：

void bubble_sort(int arr[],int n)
{ //冒泡排序
   int tmp; //记录最后一次发生数据交换的位置
   int seat = n-1;
   int flag = 0; //记录是否发生交换
   int i,j;
   for(i = 0; i < n-1 ; i++)
   {
      for(j = 0 ; j+1 <= seat ; j++)
      {
          if( arr[j] < arr[j+1] )
          {
              swap(arr[j],arr[j+1]);
              flag = 1;//表示发生过数据交换
              tmp = j; //临时记录发生交换的位置
          }
      }
      if( flag == 0 )//没有发生交换
      {
          seat = 0;
          break;
      }
      else //发生交换了，更改最后一次发生交换的位置
      {
          seat = tmp;
          flag = 0;
      }
   }
}

二、选择排序

2.1 算法思路

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

时间复杂度：平均，O(n^2) ；最好，O(n^2) ；最差，O(n^2)

void select_sort(int arr[],int n)
{
    int i,j;
    int min;
    for( i=0 ; i < n-1; i++)
    {
        min = i; //最小值的下标
        for( j= i + 1 ; j < n ; j++)
        {
            if( arr[j] < arr[min] )
            {
                min = j;
            }
        }
        if( min != i)
        {
          swap(arr[min],arr[i]);
        }
    }
}

三、插入排序

3.1 算法思路

插入排序的工作原理是，对于每个未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

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

时间复杂度

平均，O(n^2)
最好，O(n)：当每次插入一个元素都只需要比较一次时，时间复杂度变为O(n)
最差，O(n^2)

void insertion_sort(int arr[], int len) 
{
    int i, j;
    int temp;
    for (i = 1; i < len; i++) 
    {
        temp = arr[i]; //与已排序的数逐一比較，大于temp时，该数向后移

        for (j = i - 1; j >= 0 && arr[j] > temp; j--) 
            arr[j + 1] = arr[j];

        arr[j+1] = temp; //被排序数放到正确的位置
    }
}

四、希尔排序

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位

时间复杂度：

平均，O(nlogn ~ n^2)
最好，O(n^1.3)
最差，O(n^2)

4.1 算法思路

一个更好理解的希尔排序实现：将数组列在一个表中并对列排序（用插入排序）。重复这过程，不过每次用更长的列来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身仅仅对原数组进行排序（通过增加索引的步长，例如是用 i += step_size 而不是 i++）。

例如，假设有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我们以步长为8开始进行排序，我们可以通过将这列表放在有5列的表中来更好地描述算法，这样他们就应该看起来是这样：

13 14 94 33 82 25 59 94 
65 23 45 27 73 25 39 10

然后我们对每列进行排序：

13 14 45 27 73 25 39 10 
65 23 94 33 82 25 59 94

将上述两行数字，依序接在一起时我们得到：[ 13 14 45 27 73 25 39 10 65 23 94 33 82 25 59 94 ].这时13已经移至正确位置了，然后再以4为步长进行排序：

13 14 45 27 
73 25 39 10 
65 23 94 33
82 25 59 94

排序之后变为：

13 14 39 10 
65 23 45 27 
73 25 59 33
82 25 94 94

将上述四行数字，依序接在一起时我们得到：[ 13 14 39 10 65 23 45 27 73 25 59 33 82 25 94 94 ].这时13已经移至正确位置了，然后再以2为步长进行排序：

排序之后变为：

最后以1步长进行排序（此时就是简单的插入排序了）。

void shell_sort(int arr[], int len) 
{
    int gap, i, j;
    int temp;
    for (gap = len/2; gap > 0; gap = gap/2)
    {
        for (i = gap; i < len; i++)  //依次对每列进行排序
        {
            temp = arr[i];

            for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap) // 最开始只有2行，gap列
            {
                arr[j + gap] = arr[j];
            }

            arr[j + gap] = temp;
        }
    }
}