程序员成长之旅——归并排序和非比较排序（计数排序）

归并排序

基本思想

归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

归并排序一般可以用来解决外排序的问题，但有个缺点就是需要开辟O（N）的空间

图解假如是升序

时间和空间复杂度

时间复杂度：O(nlogn)
空间复杂度：O(n)

稳定性

稳定

代码实现

#include<iostream>
#include<string>
#include<stdlib.h>
using namespace std;
//递归
void _MergeSort(int* array, int left, int right, int* tmp)
{
	if (left == right)
		return;

	int mid = left + (right - left) / 2;
	//分治成左右区间都是有序的
	_MergeSort(array, left, mid, tmp);
	_MergeSort(array, mid + 1, right, tmp);

	//归并成有序的
	int begin1 = left, end1 = mid;
	int begin2 = mid + 1, end2 = right;
	int i = left;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (array[begin1] <= array[begin2])
		{
			tmp[i++] = array[begin1];
			++begin1;
		}
		else
		{
			tmp[i++] = array[begin2];
			++begin2;
		}
	}
	while (begin1 <= end1)
	{
		tmp[i++] = array[begin1];
		++begin1;
	}
	while (begin2 <= end2)
	{
		tmp[i++] = array[begin2];
		++begin2;
	}

	//最后将其拷贝到原数组
	memcpy(array + left, tmp + left, sizeof(int) * (i - left));
	
}
void MergeSort(int* array, int size)
{
	int* tmp = new int[size];
	_MergeSort(array, 0, size - 1, tmp);
	delete[] tmp;
}
//非递归
void MergeSortNonR(int* array, int size)
{
	int* tmp = new int[size];
	int gap = 1;
	while (gap < size)
	{
		for (int begin = 0; begin < size; begin += (2 * gap))
		{
			//[0,1] [begin,begin+gap]
			int begin1 = begin, end1 = begin + gap - 1;
			if (end1 >= size)
				end1 = size - 1;

			int begin2 = begin + gap, end2 = begin + 2 * gap - 1;
			if (end2 >= size)
				end2 = size - 1;

			int i = begin1;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (array[begin1] <= array[begin2])
				{
					tmp[i++] = array[begin1];
					++begin1;
				}
				else
				{
					tmp[i++] = array[begin2];
					++begin2;
				}
			}
			while (begin1 <= end1)
			{
				tmp[i++] = array[begin1];
				++begin1;
			}
			while (begin2 <= end2)
			{
				tmp[i++] = array[begin2];
				++begin2;
			}
		}
		gap *= 2;
		memcpy(array, tmp, sizeof(int) * size);
	}
	delete[] tmp;
}
void PrintSort(int* array, int size)
{
	for (int i = 0; i < size; ++i)
	{
		cout << array[i] << " ";
	}
	cout << endl;
}
int main()
{
	int array[10] = { 1,3,2,4,6,8,7,9,5,0 };
	PrintSort(array, sizeof(array) / sizeof(int));
	//MergeSort(array, sizeof(array) / sizeof(int));
	MergeSortNonR(array, sizeof(array) / sizeof(int));
	PrintSort(array, sizeof(array) / sizeof(int));
	return 0;
}

非比较排序（计数排序）

基本思想

计数排序(Count Sort) 是一个非基于比较的排序算法，该算法于1954年由 Harold H. Seward 提出。它的优势在于在对一定范围内的整数排序时，它的复杂度为Ο(n+k)（其中k是整数的范围），快于任何比较排序算法。

图解假如是升序
1.比较出来最大的数和最小的数，从而知道要开辟多大的辅助空间
2.统计出每一个数出现的次数
3.根据统计出来的次数，将其放回原来的数组中

时间和空间复杂度

时间复杂度：Ο(MAX(范围，n))
空间复杂度：Ο(n)

稳定性

稳定

代码实现

#define _CRT_SECURE_NO_WARNINGS 1
//计数排序
#include<iostream>
#include<stdlib.h>
using namespace std;
void CountSort(int* array, int size)
{
	int max = array[0];
	int min = array[0];
	for (int i = 1; i < size; ++i)
	{
		if (array[i] > max)
			max = array[i];

		if (array[i] < min)
			min = array[i];
	}
	
	int* count = new int[max - min + 1]{0};

	for (int i = 0; i < size; ++i)
	{
		int flag = array[i] - min;
		count[flag]++;
	}
	int j = 0;
	for (int i = 0; i < max - min + 1; ++i)
	{
		while (count[i] > 0)
		{
			array[j++] = min + i;
			--count[i];
		}
	}
	delete[] count;
}
void PrintSort(int* array, int size)
{
	for (int i = 0; i < size; ++i)
	{
		cout << array[i] << " ";
	}
	cout << endl;
}
int main()
{
	int array[5] = { 101,104,101,103,100 };
	PrintSort(array, sizeof(array) / sizeof(int));
	CountSort(array, sizeof(array) / sizeof(int));
	PrintSort(array, sizeof(array) / sizeof(int));
	return 0;
}