数据结构——排序

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

能够看出，冒泡排序需要两层循环控制，内层循环控制单趟排序，外层循环控制总排序次数。

n表示数据个数，所以总共需要排序n-1次，即外层循环的次数，同样也是n个数据之间两两比较的次数。

因为每经过一轮排序，我们都能排好最大值，所以每下一次排序都比上一次少一个数据 ，所以我们通过i < n - 1 - j的方式就可以完美实现这一点。当然你也可以定义一个新变量去控制，但是这样会扩大空间复杂度。

冒泡排序的时间复杂度和空间复杂度：

时间复杂度：O(N^2)

空间复杂度：O(1)

在数据本来就有序的情况下，冒泡排序的最优时间复杂度为：O(N)，即仅仅比较了数据大小，没有进行交换，所以我们可以设计一个**"探子"flag**去打探数据是否交换，如果进行一次内循环发现没有交换，就说明数据本来就有序，便直接退出外循环，节省时间。

2.选择排序

选择排序相较于冒泡排序，它是能够一次确定头尾两个位置元素的排序方式：

先定义begin和end两个标志点，分别代表要排序数据的头和尾，然后默认一段乱序数据的第一个元素同时为最小值min、最大值max ，然后从第二个数据开始分别去和它们比较，更小的值替换min，更大的值替换max，循环一次便能找到当前序列的最大值和最小值，然后再去分别和头尾元素交换，如此循环便可得出有序序列。

原码如下：

cpp 复制代码

void SelectSort(int* a, int n)
{
	int begin = 0;
	int end = n - 1;
	while (begin < end)
	{
		int mini = begin;
		int maxi = begin;
		for (int i = begin + 1; i <= end; i++)
		{
			if (a[i] < a[mini])
			{
				mini = i;
			}
			if (a[i] > a[maxi])
			{
				maxi = i;
			}
		}
		Swap(&a[begin], &a[mini]);
		if (maxi == begin)
		{
			maxi = mini;
		}
		Swap(&a[end], &a[maxi]);
		begin++;
		end--;
	}
}

不难看出，内层循环每进行一次，就能确定最大值和最小值，同时标志点begin和end向内移动，直到两者相遇，说明排序已经完成。

值得注意的是，如果恰好第一个数据就是最大值，那么maxi将得不到最大值的下标 ，而此时我们先交换了最小值和头元素，作为头元素的最大值的下标便变成了mini 。所以要进行一次判断，如果最大值是头元素，就在交换了头元素和最小值之后，将mini赋值给maxi。

选择排序的时间复杂度和空间复杂度：

时间复杂度：O(N^2)

空间复杂度：O(1)

3.堆排序

我们知道堆有大堆和小堆 两个特性，而我们的堆排序则采用大堆化小堆来进行排序。

我们默认一个堆按从上到下，从左到右的顺序为排序的顺序 ，这就要求我们要将更大的数据往堆的右下角去移动，所以要建小堆，但是单纯只是建个小堆，可能会出现下一层的元素大于上一层的情况。

所以我们要先建大堆，这样可以使根节点为为最大值，然后再将根节点与堆的最右下角元素交换，然后再将剩下的元素继续调整为大堆，如此循环往复的去交换，便可实现排序。

源码如下：

cpp 复制代码

//堆向下调整
void AdjustDown(int* a, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		if (child + 1 < size && a[child + 1] > a[child])
		{
			child++;
		}
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
//堆排序
void HeapSort(int* a, int n)
{
	//建大堆
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
	//排序
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

堆排序的时间复杂度和空间复杂度：

时间复杂度O(N*logN)

空间复杂度O(1)

4.插入排序

插入排序的原理是从第二个数据开始，依次去和它前边的数据比较，如果前边的数据比它大，就进行交换，并继续向前比较，直到前边的数据比它小为止。

源码入下：

cpp 复制代码

void InsertSort(int* a, int n)
{
    for (int i = 0; i < n - 1; i++)
    {
        int end = i;
        int tmp = a[end + 1];
        while (end >= 0)
        {
            if (tmp < a[end])
            {
                a[end + 1] = a[end];
                --end;
            }
            else
                break;
        }
        a[end + 1] = tmp;
    }
}

插入排序的时间复杂度和空间复杂度：

时间复杂度：O(N^2)

空间复杂度：O(1)

5.希尔排序

希儿排序实际上是对插入排序的一种优化：先选定一个整数n，把待排序数据分成个若干组，所有距离为n的数据在同一组内，并对每一组内的数据进行排序 。然后，取更小的整数n重复上述分组和排序的工作 。直到当n == 1时，所有数据在同一组内进行一次插入排序。

源码如下：

cpp 复制代码

void ShellSort(int* a, int n)
{
	int gap = n;
	//gap > 1是预排序，目的是让数据接近有序
	//gap = 1是直接插入排序，目的是让数据有序
	while (gap > 1)
	{
		gap = gap / 3 + 1;
		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即为所需要的整数，一般情况下，先让他等于数据长度，然后每次排序时都除以3再+1。这个并不固定，只要能保证最后gap要为1即可。

希尔排序的时间复杂度和空间复杂度：

时间复杂度：平均为O(N^1.3)

空间复杂度：平均为O(1)

6.快速排序

先来看动图：

默认第一个元素为key位，然后头尾两个"先锋兵"开始行动，其中R先向左移动，去找到比key小的值并停下，然后L开始向右移动，找到比key大的值并停下，然后交换L和R所在位置的值，并让R开始继续移动，重复上述操作，直到R和L相遇，交换相遇点与key的值，并让相遇点成为新的key。

如此操作之后，我们不难看出最后key的左边的值都比key小，而右边的值都比key大。这样我们就唯一确定了key的位置。随后我们就需要去分别排序key的左半段和右半段了 ，很显然，这需要用到递归。

源码如下：

cpp 复制代码

void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
		return;
	int left = begin;
	int right = end;
	int key = begin;
	while (left < right)
	{
		while (left < right && a[right] >= a[key])
		{
			right--;
		}
		while (left < right && a[left] <= a[key])
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[left], &a[key]);
	key = left;
	QuickSort(a, begin, key - 1);
	QuickSort(a, key + 1, end);
}

快速排序的时间复杂度和空间复杂度：

时间复杂度O(N*logN)

空间复杂度O(N*logN~O(N))

7.归并排序

先看动图：

不难看出，归并排序也是类似于一组一组的排完序后再整体进行排序。

假设我们将数据不断拆分为4组，每个小组内部先进行排序，而后1,2组排序，3,4组排序，最后排完序的两组在整体排序。

很显然，这样的排序方式同样需要用到递归，而且用一个数组是无法完成的，所以我们需要新建一个数组进行排序，再将排好的数据拷贝回去。

源码如下：

cpp 复制代码

void _MergeSort(int* a, int begin, int end, int* tmp)
{
	if (begin >= end)
		return;
	int mid = (begin + end) / 2;

	_MergeSort(a, begin, mid, tmp);
	_MergeSort(a, mid + 1, end, tmp);

	int begin1 = begin, end1 = mid;
	int begin2 = mid + 1, end2 = end;
	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++];
	}
	memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}
void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("MergeSort->malloc");
		exit(-1);
	}
	
	_MergeSort(a, 0, n - 1, tmp);
	free(tmp);
}

定义mid将数据拆分为两组，进行两组之间的排序，将排好的顺序记录在新数组tmp中 ，最后再利用memcpy拷贝回数组a中。

值得注意的是，在每个子递归函数中，所递归的数据的头都是begin，尾是end ，所以拷贝时要注意地址以及长度的写法。

归并排序的时间复杂度和空间复杂度：

时间复杂度：O(N*logN)

空间复杂度：O(N)

三.总结

七大排序的基础知识到这里就介绍完啦，而数据结构初阶的知识到这里也全部落下帷幕啦。

喜欢博主文章的小伙伴记得一键三连哦！

点关注不迷路，博主带你玩转编程！