常用排序算法描述及C++代码实现

---

前言

  排序(sort)，顾名思义，即通过特定的算法因式将一组或多组数据按照既定模式进行重新排序。这种新序列遵循着一定的规则，体现出一定的规律。在ACM竞赛题目中，根据数据规模和数据特性选择合适的排序算法常常作为解决问题的第一步，在相关行业的面试中，排序算法也是考察的热门内容之一。

  下面给出常见的排序算法及其时间复杂度与空间复杂度，需要注意的是排序算法的稳定性指在经过排序后，相同元素的相对位置是否会发生改变，如果不会发生改变，则我们说这种排序算法是稳定的，反之就是不稳定的。

一、插入排序 O(n²)

1.算法描述

  插入排序（Insertion-sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
算法实现：
1.从第一个元素开始，该元素可以认为已经被排序；
2.取出下一个元素，在已经排序的元素序列中从后向前扫描；
3.如果该元素（已排序）大于新元素，将该元素移到下一位置；
4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5.将新元素插入到该位置后；
6.重复步骤2~5。

2.代码实现

void insertion_sort(int q[], int l, int r)
{
    for (int i = l; i <= r; i ++ )
	{
        int key = q[i];                    //当前要插的数 
        int j = i - 1;                      
        while((j >= 0) && (key < q[j]))    //从i-1开始向前遍历，直到找到应当插入的位置 
		{
            q[j + 1] = q[j];
            j -- ;
        }
        q[j + 1] = key;                    //将值插入 
    }
}

二、选择排序 O(n²)

1.算法描述

  选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
算法实现：
1.初始状态：无序区为R[1…n]，有序区为空；
2.第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
3.n-1趟结束，数组有序化了。

2.代码实现

void selection_sort(int q[], int l, int r)
{
    for (int i = l; i < r; i++)                //遍历整个数组 
    {
    	int min = i;
    	for(int j = i + 1; j <= r; j ++ )      //找出未排序区域内的最小值的位置 
    	{
    		if (q[j] < q[min]) min = j;
		}
		swap(q[i], q[min]);                    //将未排序区域内的最小值与未排序区域的第一个值交换 
	}	 
}

三、冒泡排序 O(n²)

1.算法描述

  冒泡排序（Bubble-sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
算法实现：
1.比较相邻的元素。如果第一个比第二个大，就交换它们两个；
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
3.针对所有的元素重复以上的步骤，除了最后一个；
4.重复步骤1~3，直到排序完成。

2.代码实现

void bubble_sort(int q[], int l, int r)
{
    for (int i = l; i < r; i ++ )                          //共进行n-1次循环 
	{
		for(int j = 0; j < r - i; j ++ )                   //每次循环遍历前面的无序序列，将最大值“沉”到后面，较小值“冒泡”到前面 
		{
			if (q[j] > q[j + 1]) swap(q[j], q[j + 1]);
		}
	} 
}

四、快速排序 O(nlogn)

1.算法描述

  快速排序（Quick-sort）的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
算法实现：
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
1.从数列中挑出一个元素，称为 “基准”（pivot）；
2.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
3.递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

2.代码实现

void quick_sort(int q[], int l, int r)
{
    if (l >= r) return;                                //如果区间内只有1个元素或者没有元素，直接返回。 

    int i = l - 1, j = r + 1, x = q[(l + r) / 2];      //注意i和j的初值为什么要-1和+1 
    while (i < j)                                      //当两个指针没有相遇时，进行分组操作 
    {
        do i ++ ; while (q[i] < x);
        do j -- ; while (q[j] > x);
        if (i < j) swap(q[i], q[j]);
    }

    quick_sort(q, l, j);                               //递归左右两段 
    quick_sort(q, j + 1, r);
}

五、归并排序 O(nlogn)

1.算法描述

  归并排序(Merge-sort)是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
算法实现：
1.把长度为n的输入序列分成两个长度为n/2的子序列；
2.对这两个子序列分别采用归并排序；
3.将两个排序好的子序列合并成一个最终的排序序列。

2.代码实现

void merge_sort(int q[], int l, int r)
{
    if (l >= r) return;                                       //如果区间内只有1个元素或者没有元素，直接返回。 

    int mid = l + r >> 1;                                     //每次的分界点是区间的中央。 

    merge_sort(q, l, mid), merge_sort(q, mid + 1, r);         //递归排序左右两段 

    int k = 0, i = l, j = mid + 1;                            //k表示已经排序好的元素个数，i和j分别指向两个排序区间的首元素（最小值） 
    while (i <= mid && j <= r)                                //两个区间内还有元素没有被归并的前提下取两个指针指向的元素中较小值加入tmp数组
	{                                                         //的尾部 
        if (q[i] <= q[j]) tmp[k ++ ] = q[i ++ ];
        else tmp[k ++ ] = q[j ++ ];
    } 
    while (i <= mid) tmp[k ++ ] = q[i ++ ];                   //如果其中一个区间内还有元素没有被归并完，直接依次加入tmp数组的尾部 
    while (j <= r) tmp[k ++ ] = q[j ++ ];

    for (i = l, j = 0; i <= r; i ++, j ++ ) q[i] = tmp[j];    //将tmp数组复制到q数组 
}