常规的排序算法汇总

前言

排序算法，在职业生涯中，时常有用到，不论是在项目中，还是在面试中。
在这里记录一下常用的排序算法，也给自己插个眼。
排序算法分为：冒泡排序、插入排序、选择排序、快速排序、希尔排序、堆排序、基数排序、归并排序八大排序。

时间复杂度和空间复杂度

排序方法	时间复杂度（平均）	时间复杂度（最好）	时间复杂度（最坏）	空间复杂度	稳定性
冒泡排序	O(n^2)	O(n^2)	O(n)	O(1)	稳定
插入排序	O(n^2)	O(n^2)	O(n)	O(1)	稳定
选择排序	O(n^2)	O(n^2)	O(n)	O(1)	不稳定
快速排序	O(nlog2n)	O(n^2)	O(nlog2n)	O(nlog2n)	不稳定
希尔排序	O(n^1.3)	O(n^2)	O(n)	O(1)	不稳定
堆排序	O(nlog2n)	O(nlog2n)	O(nlog2n)	O(1)	不稳定
归并排序	O(nlog2n)	O(nlog2n)	O(nlog2n)	O(n)	稳定
基排序	O(n*k)	O(n*k)	O(n*k)	O(n+k)	稳定

冒泡排序

思路：

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个.
2. 对每一个相邻元素做同样的工作，从开始第一对到结尾的每一对。在这一 点，最后的元素应该会是最大的数。
3. 针对多有的元素重复以上的步骤，除了最后一个。

/// <summary>
/// 冒泡排序
/// </summary>
/// <param name="arry">排序数组</param>
public void BubbleSort(int[] arry)
{
   int count = arry.Length;
   for (int i = 0; i < count; i++)
   {
       for (int j = count-1; j < i; j++)
       {
           if (arry[j-1]>arry[j])
           {
               var temp = arry[j - 1];
               arry[j - 1] = arry[j];
               arry[j] = temp;
           }
       }
   }
}

插入排序

思路

• 插入排序是最简单常用的方法，将数组分为两部分，排好序的数列，以及未排序的数列，将未排序的数列中的元素 与排好序的数列进行比较，然后将该元素插入到已排序列的合适位置中。

// 第一种方式
void insertSort(int *arr, int len)
{
    for (int i = 1; i < len; i++)
    {
        int tmp = arr[i];
        for (int j = i - 1; j >= 0; j--)
        {
            if (arr[j] > tmp)
            {
                arr[j + 1] = arr[j];
            }
            else
            {
                break;
            }
        }
        arr[j + 1] = tmp;
    }
}
// 第二种方式
void insertSort(int n[], int size)
{
    for (int i = 1; i < size; i++)
    {
        for (int j = i; j > 0; j--)
        {
            if (n[j] < n[j - 1])
            {
              swap(n[j], n[j - 1]);
            }
            else
            {
              break;
            }
        }
    }
}

选择排序

思路

• 每一次从无序组的数据元素中选出最小的一个元素，存放在无序组的起始位置，无需组的元素减少，有序组的元素增加，直到全部待排序的数据元素排完。

void choiceSort(int n[], int size)
{
    for (int i = 0; i < size - 1; i++)
    {
        int k = i; //表示当前的最小值下标
        for (int j = i + 1; j < size; j++)
        {
            if (n[j] < n[k])
            {
              k = j;
            }
        }
        if (k != i)
        {
          	swap(n[k], n[i]);
        }
    }
}

快速排序

思路：

• 快速排序是找出一个元素（理论上可以随便找一个）作为基准，然后对数组进行分区操作，使基准左边元素的值都不大于基准值，基准右边的值都不小于基准值，如此作为基准的元素调整到排序后的正确位置。递归快速排序，将其他n - 1 个元素也调整到排序后的正确位置。最后每个元素都是在排序后的正确位置，排序完成。
• 所以快速排序算法的核心算法是分区操作，及如何调整基准的位置以及调整返回基准的最终位置以便分治递归。

void quickSort(int e[], int start, int end)
{
    if (start >= end) //当start>=end时,跳出
      return;
    int i = start, j = end, temp = e[start];
    while (i < j)
    {
        while (i < j && e[j] >= temp)
          	j--;
        e[i] = e[j];
        while (i < j && e[i] <= temp)
          	i++;
        e[j] = e[i];
    }
    e[i] = temp;
    quickSort(e, start, i - 1);
    quickSort(e, i + 1, end);
}

希尔排序

思路：

• 把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

void shellSort(int n[], int size)
{
	// 每一次的增量:[5,2,1]
    for (int gap = size / 2; gap > 0; gap /= 2)
    {
        // 从后往前，对用增量间隔的序列采取插入排序
        for (int i = gap; i < size; i++)
        {
            for (int j = i; j >= gap; j -= gap)
            {
                if (n[j] < n[j - gap])
                {
                  	swap(n[j], n[j - gap]);
                }
                else
                {
                  	break;
                }
            }
        }
    }
}