【Leetcode】经典排序算法学习C++

冒泡排序：与未排序的元素进行比对，将最大元素至于最后；

选择排序：从未排序的元素中选择最小元素，将其置于数组最前方；

插入排序：将元素与已排序元素进行比对，将其插入合适位置，排序从小到大。

1、冒泡排序（Bubble Sort）

    冒泡排序 是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

  1.3 代码实现

• 1.1 算法描述
  • 步骤1: 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
  • 步骤2: 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
  • 步骤3: 针对所有的元素重复以上的步骤，除了最后一个；
  • 步骤4: 重复步骤1~3，直到排序完成。
• 1.2 动图演示

 

// base_sort.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

void BubbleSort(int* data, int total_len) 
{
	int temp = 0;
	for (int i = 0; i < total_len - 1; i++) {
		for (int j = 0; j < total_len - i - 1; j++) {
			if (data[j] > data[j+1]) {
				temp = data[j];
				data[j] = data[j+1];
				data[j+1] = temp;
			}
		}
	}
}

int main()
{
    int test_data[] = {1,6,2,3,9,0,3,4,65,5};
    BubbleSort(test_data, sizeof(test_data)/ sizeof(test_data[0]));
    return 0;
}

• 1.4 时间复杂度

  这个时间复杂度还是很好计算的：外循环和内循环以及判断和交换元素的时间开销；

         最优的情况也就是开始就已经排序好序了，那么就可以不用交换元素了，则时间花销为：[ n(n-1) ] /  2；所以最优的情况时间复杂度为：O( n^2 )；

         最差的情况也就是开始的时候元素是逆序的，那么每一次排序都要交换两个元素，则时间花销为：[ 3n(n-1) ] / 2；（其中比上面最优的情况所花的时间就是在于交换元素的三个步骤）；所以最差的情况下时间复杂度为：O( n^2 )；

          综上所述：

         最优的时间复杂度为：O( n^2 ) ；有的说 O(n)，下面会分析这种情况；

         最差的时间复杂度为：O( n^2 )；

         平均的时间复杂度为：O( n^2 )；

最优时间复杂度 n
        有很多人说冒泡排序的最优的时间复杂度为：O(n)；其实这是在代码中使用一个标志位来判断是否已经排序好的，修改下上面的排序代码：

 void bubbleSort(int array[], int length)
 {
     int i, j, tmp;
     int flag = 1;
     
     if (1 >= length) return;
 
     for (i = length-1; i > 0; i--, flag = 1){ 
         for (j = 0; j < i; j++){
             if (array[j] > array[j+1]){
                 tmp        = array[j];
                 array[j]   = array[j+1];
                 array[j+1] = tmp;
                 flag = 0;
             }   
         }   
         if (flag) break;
     }   
 }

        根据上面的代码可以看出，如果元素已经排序好，那么循环一次就直接退出。或者说元素开始就已经大概有序了，那么这种方法就可以很好减少排序的次数；其实我感觉这种方法也有弊端，比如 要额外的判断下，以及赋值操作。

2、选择排序（Selection Sort）

    选择排序 是表现最稳定的排序算法之一 ，因为无论什么数据进去都是O(n2)的时间复杂度 ，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

    选择排序(Selection-sort) 是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.3 代码实现 

• 2.1 算法描述
  
      n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：
  • 步骤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.2 动图演示

void SelectSort(int* data, int total_len)
{
	int mark = 0;
	for (int i = 0; i < total_len - 1; i++) {
		mark = i;
		for (int j = i+1; j < total_len; j++) {
			if (data[mark] > data[j]) {
				mark = j;
			}
		}
		if (mark != i) {
			int temp = data[i];
			data[i] = data[mark];
			data[mark] = temp;
		}
	}
}

int main()
{
	int test_data[] = {1,6,2,3,9,0,3,4,65,5};
	//BubbleSort(test_data, sizeof(test_data)/ sizeof(test_data[0]));
	SelectSort(test_data, sizeof(test_data) / sizeof(test_data[0]));
    return 0;
}

3、插入排序（Insertion Sort）

    插入排序（Insertion-Sort） 的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

 

• 3.1 算法描述
  
  一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
  • 步骤1: 从第一个元素开始，该元素可以认为已经被排序；
  • 步骤2: 取出下一个元素，在已经排序的元素序列中从后向前扫描；
  • 步骤3: 如果该元素（已排序）大于新元素，将该元素移到下一位置；
  • 步骤4: 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
  • 步骤5: 将新元素插入到该位置后；
  • 步骤6: 重复步骤2~5。
• 3.2 动图演示

 

void InsertSort_bad(int* data, int total_len) {
	if (total_len > 1) {
		for (int i = 0; i < total_len - 1; i++) {
			for (int j = i + 1; j >= 0; j--) {
				if (data[j] < data[j - 1]) {
					int temp = data[j];
					data[j] = data[j-1];
					data[j - 1] = temp;
				}
				else
				{
					break;
				}
			}
		}
	}
}

void InsertSort(int* data, int total_len) {
	for (int i = 0; i < total_len - 1; i++) {
		int CurrentData = data[i + 1];
		int MarkIndex = i;
		while (MarkIndex >= 0 && CurrentData < data[MarkIndex]) {
			data[MarkIndex + 1] = data[MarkIndex];
			MarkIndex--;
		}
		data[MarkIndex+1] = CurrentData;
	}
}

int main()
{
    int test_data[] = {1,6,2,3,9,0,3,4,65,5};
	//BubbleSort(test_data, sizeof(test_data)/ sizeof(test_data[0]));
	//SelectSort(test_data, sizeof(test_data) / sizeof(test_data[0]));
    InsertSort(test_data, sizeof(test_data) / sizeof(test_data[0]));
    return 0;
}

4、希尔排序（Shell Sort）

    希尔排序是希尔（Donald Shell） 于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n2）的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

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

• 4.1 算法描述
  
      我们来看下希尔排序的基本步骤，在此我们选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2…1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。
  
      先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
  • 步骤1：选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
  • 步骤2：按增量序列个数k，对序列进行k 趟排序；
  • 步骤3：每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
• 4.2 过程演示

 

void ShellSort(int* data, int total_len) {
	int gap = total_len / 2;
	while (gap > 0) {
		for (int i = gap; i < total_len; i++) {
			int preIndex = i - gap;
			int temp = data[i];
			while (preIndex >= 0 && data[preIndex] > temp) {
				data[preIndex+gap] = data[preIndex];
				preIndex -= gap;
			}
			data[preIndex + gap] = temp;
		}
		gap = gap / 2;
	}
}

int main()
{
	int test_data[] = {1,6,2,3,9,0,3,4,65,5,0};
	//BubbleSort(test_data, sizeof(test_data)/ sizeof(test_data[0]));
	//SelectSort(test_data, sizeof(test_data) / sizeof(test_data[0]));
	//InsertSort(test_data, sizeof(test_data) / sizeof(test_data[0]));
	ShellSort(test_data, sizeof(test_data) / sizeof(test_data[0]));
    return 0;
}

4.4 算法分析