21天算法打卡系列（3）

活动地址：CSDN21天学习挑战赛

今天的内容依旧是排序算法。
首先是基础算法，直接选择排序

直接选择排序

算法思想：每次在数组中选择一个最小值，将最小值与数组第一个元素交换，然后再找出数组第二个到最后的元素中的最小值，将他放在数组第二个元素的位置。

我写的时优化版本：思想时选择排序的思想，不一样的是，每次选出来两个值，一个最大值一个最小值。然后分别和开始位置和结束位置交换。要注意一个问题，当最大值下标和begin重合时，此时交换mini位置的值和begin位置的值，maxi的值会被交换到mini指向的位置，所以此时要特殊判断。

//选择排序
void SelectSort(int* arr, int sz)
{
	int begin = 0;
	int end = sz - 1;
	int mini = 0;
	int maxi = 0;
	while (begin <= end)
	{
		mini = begin;//记得每次交换完要更新mini和maxi
		maxi = begin;
		for (int i = begin; i <= end; i++)
		{
			if (arr[i] < arr[mini])
			{
				mini = i;
			}
			if (arr[i] > arr[maxi])
			{
				maxi = i;
			}
		}
		Swap(&arr[begin], &arr[mini]);
		if (maxi == begin)
		{
			maxi = mini;//特殊判断。
		}
		Swap(&arr[end], &arr[maxi]);
		begin++;
		end--;
	}
}

关于排序算法，需要了解的还有很多，今天带来的第二个排序算法就是归并排序

归并排序

递归归并排序

算法思想:实际使用的就是分治思想，我想要假设八个数组元素有序，只需要分成两组四个元素的数组，这两组都有序，归并起来就是整体有序，想要四个元素有序怎么办呢？继续分治呗，分成两个元素的数组，两个元素怎么有序？再次分，分成一个元素，一个元素就是有序的，归并起来就可以了，总体就是先分后归。
分治思想：就是要求一个大问题，先将他分成小问题，小问题再分成小小问题，直到不可再分割，最后再将小问题合并即可。
*这里的归并有点类似二叉树的后序遍历，先将数组分为左右区间，左区间有序，右区间，有序，就归并，左右区间类似二叉树的左右子树

//归并排序
void _MergeSort(int* a, int left, int right, int* tmp)
{
	if (left >= right)
		return;
	//左区间有序，右区间有序，然后归并就整体有序了。
	int mid = (left + right) >> 1;
	_MergeSort(a, left, mid, tmp);
	_MergeSort(a, mid + 1, right, tmp);
	//左右都有序，归并
	int begin1 = left, end1 = mid;
	int begin2 = mid + 1, end2 = right;
	int index = left;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[index++] = a[begin1++];
		}
		else
		{
			tmp[index++] = a[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		tmp[index++] = a[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[index++] = a[begin2++];
	}
	//拷贝回去
	for (int i = left; i <= right; i++)
	{
		a[i] = tmp[i];
	}
}


void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	_MergeSort(a, 0, n - 1, tmp);
	free(tmp);
}

非递归归并排序

递归转换为非递归的时候能用循环就用循环，这里要特别注意边界条件的判断，比如，到最后的一组，左区间不完整就直接不进行归并，也就死begin2>=n就跳出循环，当左区间存在但是右区间不完整就调整右区间，end2>=n,将end2变为n-1；进行归并就可以。

//归并排序非递归
void MergeSortNor(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	int gap = 1;
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)
		{
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			if (begin2 >= n)
			{
				break;
			}
			if (end2 >= n)
			{
				end2 = n - 1;
			}

			int index = i;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1]<a[begin2])
				{
					tmp[index++] = a[begin1++];
				}
				else
				{
					tmp[index++] = a[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				tmp[index++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[index++] = a[begin2++];
			}
			for (int j = i; j <index; j++)//将本次归并的结果拷贝回原数组（起点是i，不能用begin1，因为begin1以及被改变了）。
			{
				a[j] = tmp[j];
			}
		}
		gap *= 2;
	}
	free(tmp);//防止内存泄露
}

上面的归并排序已经将归并的思维讲述清楚了，简单来说就是先将序列分为两部分，然后让这两部分都有序之后就进行归并，那么如果让两部分都有序呢？再次分割，直到区间只有一个元素，此时就是有序的，所以就可以进行归并了。

堆排序

与选择排序有类似思想的就是堆排序，堆排序就是先建堆，然后将堆顶的元素与最后一个元素交换，然后使用向下调整算法，将堆重新调整，依次进行，实际还是选择排序，只是选出最大值或者最小值的过程被优化到了logn也就是向下调整。

算法思想：先建堆（升序建大堆）建堆使用从下向上建堆，选择倒数第一个子树不为0
NULL的父节点开始一次向上建堆。使用向下调整算法（时间复杂度是O（N）），建堆完成后，将堆顶的元素与数组最后的元素交换位置，因为大堆堆顶一定是最大的元素，然后将数组长度缩减1，对n-1个数向下调整，（向下调整的前提条件是：左右子树都是大堆），因为交换只改变了堆顶的元素，所以满足条件，直接向下调整即可。直到数组只剩下一个元素，跳出循环，这时候排序结束。

大堆就是孩子节点都<=父节点，小堆就是孩子节点都>=父亲节点。

解释为什么升序要建大堆，因为如果是建的小堆，每次堆顶都是最小的元素，如果取出堆顶的元素，那么剩下的n-1个元素的再次取第二小的时候，树的结构已经乱了，就需要重新建堆O（N），这样堆排序就没有意义了。

void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
void AdjustDown(int* a, int n, int root)
{
	int parent = root;
	int child = root * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && 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;
	}

}
void TestHeapSort()
{
	int arr[] = { 1,0,9,8,7,4,6,5,3,2 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	HeapSort(arr, sz);
	Printarr(arr, sz);
}