七大排序的时间复杂度和空间复杂度

七大排序的分类

时间复杂度

时间复杂度是指一个程序中基本语句被执行的次数,一般认为是最坏情况。

空间复杂度

空间复杂度是指在一个程序执行时要额外开辟的空间大小。

稳定性

什么是稳定性呢？这里的稳定性不是指时间复杂度稳定,而是原数据中相同值的前后位置是否会发生改变。
例如 1 2 1 4 5如果在排序的过程中第二个1跑到了第一个1的前面,那么我们就说这个排序不稳定,记住是相同值的前后位置。当然是指有能力做到稳定我们就说它稳定,如果想让一个排序不稳定我们都能做到让它不稳定。

直接插入排序

直接插入排序就是从第i个数开始依次向前i-1个有序数中插入。

//插入排序
void InsertSort(int* a, int n)
{
	assert(a);
	//将无序数组排成有序
	//从第一个值开始向前比较,前n个值有序再让第n+1个值插入,前面的有序数组
	for (int end = 1; end < n; end++)
	{
		//单趟排序 将一个值插入一个有序数组
		//值会被覆盖,所以要提前保存
		int x = a[end];
		int j;
		for (j = end - 1; j >= 0; j--)
		{
			//此时n是最后一个元素的下标
			if (x < a[j])
			{
				a[j + 1] = a[j];
			}
			else
			{
				break;
			}
		}
		a[j + 1] = x;
	}
}

最好情况时,数组是有序的,时间复杂度为O(n)
最坏情况时,数组是逆序的,时间复杂读为1/2 * n * (n + 1),所以对应的也就是O(n2)
所以直接插入的时间复杂度为O(n)~O(n2)
空间复杂度：O(1)
稳定性:稳定

希尔排序

希尔排序就是把数据进行分组,然后对每组数据进行排序,每组的数据个数逐渐增加,被分成的组数也就逐渐变少。

// gap > 1 预排序
// gap == 1 直接插入排序
void ShellSort(int* a, int n)
{
	//思想:分组排序,让数据尽量有序,接着让间距gap逐渐减小到1
	//gap例如 gap = 2时,1,3,2,4,5----1,2,5是一组,3,,4是一组
	int gap = n;
	int end = 0;
	while (gap > 1)
	{
		gap /= 2;
		//选定要插入的数据
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = a[end + gap];
			//插入
			while (end >= 0)
			{
				if (tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

当然这里的gap也可以是n/3
至于时间复杂度：
希尔排序的特性总结：

1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就
   会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的
   希尔排序的时间复杂度都不固定：
   《数据结构(C语言版)》— 严蔚敏
   

空间复杂度这里我们就很容易计算,因为都是在原数组上进行操作的,所以空间复杂度为O(1)
稳定性：不稳定

选择排序

选择排序:从第当前位置开始依次向后遍历找到最大或最小(降序或升序)然后和它交换。
我们也可以同时记录两个位置找到最大和最小。在升序中让最小和第i位置交换,让最大和第n-1-i位置交换,此外还要考虑到一种特殊情况第i位置就是最大值时,在找到最小后它和下标为min的最小值交换了,所以此时第n-1-i位置就要和min位置的值交换了。

//方法二
void SelectSort(int* a, int n)
{
	int left, right;
	int mini, maxi;

	left = 0;
	right = n - 1;
	while (left < right)
	{
		
		mini = left;
		maxi = left;
		for (int i = left + 1; i <= right; i++)
		{
			//找出最大和最小值的下标
			if (a[i] < a[mini])
			{
				mini = i;
			}
			if (a[i] > a[maxi])
			{
				maxi = i;
			}
		}
		Swap(&a[left], &a[mini]);
		//要考虑最初定义的mini是不是max,如果是那么在上面的交换后,它就被换走了。
		if (maxi == left)
		{
			Swap(&a[right], &a[mini]);
		}
		else
		{
			Swap(&a[right], &a[maxi]);
		}
		left++;
		right--;
	}
}

这里是同时找最大和最小,单项选择和双向选择的区别就是,双向选择可以少走一些选择的过程,但是对应的时间复杂度并没有发生改变都是O(n2)。
单向：1/2*(n-1 + 1)* 对应的量级就是O(n2)
双向：大致 1/2*(n-1 + 2)n1/2 因为它少走了一般的路程所以要除以2,但是量级没有改变,仍是O(n2)
直接选择排序与原数据顺序无关。
空间复杂度:O(1)
稳定性:不稳定

堆排序

堆排序,要先进行建堆,大根堆或者小根堆,再根据topk问题原理将topk与最后一个值交换,所以此时最后一个值也就在第一个位置,再让它进行向下调整。
向上建堆的过程时间复杂度为：最差为n*logn-n
调整的时间复杂度:

一共有log2n层,从第1层开始向下调整,调整次数由n到1,调整的数据个数也由2^(n-1) 到 2^1个
然后利用错位相减法得到的结果是log2n * h * 2^(h - 1),其中h * 2^(h - 1)也就数据的总个数n,所以就可大致得出时间复杂度为O(n*log2n),堆排序不会受原数据顺序的影响,因为都要从top开始向下调整到最后。
空间复杂度：都是在原数组上进行操作的,只有一些额外的临时变量,可归为O(1)
稳定性:不稳定 例如对大根堆排升序时,数组值顺序为2 2 1,第一次调完之后就变成了 2 1 2
注意这里粗体和斜体2的位置变化

冒泡排序

void BubbleSort(int* a, int n)
{
	assert(a);
	assert(n);
	for (int i = 0; i < n; i++)
	{
		bool exchange = false;
		for (int j = 1; j < n - i; j++)
		{
			if (a[j] < a[j - 1])
			{
				Swap(&a[j], &a[j - 1]);
				exchange = true;
			}
		}
		if (exchange == false)
		{
			break;
		}
	}
}

冒泡排序的时间复杂度:
冒泡排序的基本语句就是Swap语句
Swap执行次数由n次逐渐减少到1次。
所以执行总次数为[ n*(1+n)] / 2。所以时间复杂度为N^2;(计算复杂度时系数可以省略,粗略计算n+1近似于n)
当原数据本来就有序时,只需遍历一遍即可,判断一下数据有么有发生交换,因为有序所以没有交换,就可直接跳出,此时的时间复杂度为O(N)。
所以综上所述冒泡排序与原数据有关,时间复杂度为O(N)~O(N^2)。
冒泡排序的空间复杂度:
这里的数组空间是已经开辟好的,不属于在这个排序空新开辟的,所以不计算在内。而这里只有一些i,j等变量属于新开辟的,且它们只开辟一次空间就够了,后面会重复利用,即所有的i,j都共用一个存储空间, 所以他们是属与O(1)这个量级的,即它的空间复杂度为0(1)；
稳定性:稳定

快速排序

// 快速排序hoare版本
int PartSort1(int* a, int left, int right)
{
	//设一个数作为基准,我们一般选择最左边或者是最右边的数作为基准,
	//最终结果是基准的左右两边分别大于和小于它或小于大于它,具体看是排升序还是降序
	//我们以排升序举例
	//int keyi = left;
	//如果数据已经接近有序,那么直接选取某一个数作为基准很有可能会导致栈溢出,
	int midi = GetMidIndix(a, left, right);
	//让选择的基准和最左边的值换位置
	Swap(&a[midi], &a[left]);
	int keyi = left;
	while (left < right)
	{
		//找小
		//考虑特殊情况 数据全相等,
		//数据本来就是非降序排好的
		while (left < right && a[right] >= a[keyi])//为什么要加等于号?
		{
			right--;
		}
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[keyi], &a[left]);
	return left;//返回a[keyi]现在所在的下标,就是为了找到将数据一分为二的下标,一边比它大一边比他小
}

快速排序也与原数据有关,是否接近有序,它的最好情况时时间复杂度为nlogn
如上图递归深度为logn,每一层比较的数都为n，最后几层可能会不为n,但是也接近,所以比较执行的总次数为nlogn。
当它为逆序时最坏,时间复杂度为n2,因为逆序所以它递归的深度为n，每一层比较的数都为n，最后几层可能会不为n,但是也接近,所以比较执行的总次数为N^2。
综上所述,快速排序最好情况时,时间复杂度为n*logn,最坏情况时复杂度为n^2。
空间复杂度:最好时递归深度为logn,最坏时递归深度为n,每次开辟的空间是为基准keyi开辟的,里面存放的就是基准下标,最好情况时要选logn次基准,最坏情况时要选n次基准,所以快速排序的空间复杂度为O(logn)~O(n)。

归并排序

我们这里说的归并排序是二路归并。
把每个元素都分开,然后两两合直到合并到没有元素,再合并的过程中进行排序。

//递归实现
void _MergeSort(int* a, int begin, int end, int* tmp)
{
	assert(a);
	if (begin  >= end)//有大于的情况吗?
	{
		return;
	}
	//归并排序实质上对应于后序遍历
	// 求中位数是两边之和除以二
	//int mid = (end - begin - 1) / 2;
	int mid = (begin + end) / 2;
	_MergeSort(a, begin, mid, tmp);
	_MergeSort(a, mid + 1, end, tmp);
	int begin1 = begin;
	int end1 = mid;
	int begin2 = mid + 1;
	int end2 = end;
	//注意每次递归中的i等于begin
	int i = begin;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		else
		{
			tmp[i++] = a[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		tmp[i++] = a[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[i++] = a[begin2++];	
	}
	//最后别忘了把数据拷贝到原数组
	//注意拷贝的源位置和目标位置,要加上begin
	memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}

归并排序应用的是标准的二分法,最好和最坏情况时间复杂度都是nlog2n,解释:一共需要分log2n层,每一层都有n个数据要进行比较,且与原数据顺序无关。
空间复杂度：O(n)因为创建了一个临时数组tmp,且每次递归调用都是用的同一个临时数组,并不是开辟了nlog2n个临时空间。
稳定性:稳定

总结