C++实现五种常见排序算法_排序算法c++实现

一、 算法复杂度
稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数
二、算法
1、 冒泡排序
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
1.1 算法描述
比较相邻的元素。如果第一个比第二个大，就交换它们两个；
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
针对所有的元素重复以上的步骤，除了最后一个；
重复步骤1~3，直到排序完成。

void Bubble_Sort(int *a, int len)
{
	for (int i=0; i<len-1; i++)
	{
		for (int j=0; j<len-i-1; j++)
		{
			if (a[j]>a[j+1])
			{
				int temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
			}
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2、选择排序（Selection Sort）
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
2.1 算法描述
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

初始状态：无序区为R[1…n]，有序区为空；
第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个的新无序区；
n-1趟结束，数组有序化了。

void Selection_Sort(int *a, int len)
{
	int minIndex;
	int temp;
	for (int i=0; i<len-1; i++)
	{
		minIndex = i;
		for (int j=i+1; j<len; j++)
		{
			if (a[j]<a[minIndex])
			{
				minIndex = j;
			}
		}
		temp = a[i];
		a[i] = a[minIndex];
		a[minIndex] = temp;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3、插入排序（Insertion Sort）
插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

3.1 算法描述
一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

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

void Inser_Sort(int a[], int len)
{
    int j;
    int current;

    for(int i=0; i<len; i++)
    {
        j = i ;
        current = a[i];

        while(j>=0 && a[j-1]> current)
        {
            a[j] = a[j-1];
            j--;
        }
        a[j] = current;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4、快速排序
快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

4.1 算法描述
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

从数列中挑出一个元素，称为 “基准”（pivot）；
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

void quickSort(int* a, int left, int right)
{
  if (left >= right) {
    return;
  }

  int base = a[((left+right)/2)];
  int i = left;
  int j = right;

  while (i <= j)
  {
    while(a[i]<base){
      i++;
    }

    while(a[j]>base){
      j--;
    }

    if (i<=j) {
      int temp = a[i];
      a[i] = a[j];
      a[j] = temp;
      i++;
      j--;
    }
  } 
  quickSort(a, left, j);
  quickSort(a, i, right);
}

int getStandard(int array[], int i, int j) {
	//基准数据 
	int key = array[i];
	while (i < j) {
			//因为默认基准是从左边开始，所以从右边开始比较 
			//当队尾的元素大于等于基准数据 时,就一直向前挪动 j 指针 
			while (i < j && array[j] >= key) {
				j--;
			}
			//当找到比 array[i] 小的时，就把后面的值 array[j] 赋给它 
			if (i < j) {
				array[i] = array[j];
			}
			//当队首元素小于等于基准数据 时,就一直向后挪动 i 指针 
			while (i < j && array[i] <= key) {
				i++;
			}
			//当找到比 array[j] 大的时，就把前面的值 array[i] 赋给它
			if (i < j) {
				array[j] = array[i];
			}
		}
	//跳出循环时 i 和 j 相等,此时的 i 或 j 就是 key 的正确索引位置
	//把基准数据赋给正确位置 
	array[i] = key;
	return i;
}

void QuickSort(int array[], int low, int high) {
	//开始默认基准为 low
	if (low >= high) 
    {
        return;
    }

    //分段位置下标 
    int standard = getStandard(array, low, high);
    //递归调用排序
    //左边排序 
    QuickSort(array, low, standard - 1);
    //右边排序 
    QuickSort(array, standard + 1, high);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

5、堆排序
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

5.1 算法描述
将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

//将i节点为根的堆中小的数依次上移,n表示堆中的数据个数
void MaxHeapInfy(int *a, int i, int n)
{
	int l = 2 * i + 1;//i的左儿子
	int r = 2 * i + 1;//i的右儿子

	int largest = i;//先设置父节点和子节点三个节点中最大值的位置为父节点下标
	if (l<n && a[l]>a[largest])
	{
		largest = i;
	}

	if (r<n && a[r]>a[largest])
	{
		largest = r;
	}

	if (largest != i)
	{
		swap(a[i], a[largest]);

		MaxHeapInfy(a, largest, n);  //递归调用，保证子树也是最大堆		
	}
}

void BuildMaxHeap(int *a, int n)  //建立最大堆

{
	// 从最后一个非叶子节点（n/2-1）开始自底向上构建，
	for (int i = n / 2 - 1; i >= 0; i--)  //从（n/2-1）调用一次maxHeapIfy就可以得到最大堆

		MaxHeapInfy(a, i, n);

}

void Heap_Sort(int *a, int n)
{
	BuildMaxHeap(a,n);

	for (int i = n - 1; i > 0; i--)
	{
		// 将根节点(最大值)与数组待排序部分的最后一个元素交换,这样最终得到的是递增序列
		swap(a[0], a[i]);
		// 待排序数组长度减一,只要对换到根节点的元素进行排序，将它下沉就好了。
		MaxHeapInfy(a, 0, i);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48