排序之堆排序

堆排序

  堆排序的前提是要有堆，而堆只要两种，一种是大根堆，一种是小根堆。

大根堆

  那什么是大根堆呢？
  从名字来看，大根大根可以联想到有一个树里面有一个大根。那树里面的大根联想树的根结点大于等于左右子树。

  仔细观察，对于任意一课树，或者任意一颗子树，都有其父亲结点大于孩子结点。这就是大根堆的特性。

小根堆

  同样的道理，可以得出结论：对于任意一课树，或者任意一颗子树，都有其父亲结点小于等于孩子结点。这就是小根堆的特性。

孩子结点和父亲结点的关系

以结点25为父亲结点。则36是它的左孩子，48为它的右孩子。

leftchild = parent *2+1;
   3 = 1 * 2+1;

rightchild = parent *2+2;
  4=1 * 2+2;

parent = (child -1)/2;
  1=(3-1)/2;
  1=(4-1)/2;

理解了上面的知识，我们继续向下看。

向下调整算法

  向下调整算法的前提是左右子树都是小根堆。

开始向下调整。
思想： 找出根结点中左右子树的最小值，如果最小值比根结点小，则交换根结点和找出子树中的最小值。将根结点转移到最小值的子树位置。
  在下面这副图中，p代表根结点，c代表根结点最小值的子树。一直循环到p结点为叶子结点则停止。

向下调整核心代码

void AdjustSort(int *a,int n,int root)
{
	//找到父结点
	int parent = root;
	//默认为左子树
	int child = parent * 2 + 1;
	//从图中可以看到，当p结点为叶子结点时
	//c几点已经超出了数组长度n.
	while (child < n)
	{
		//如果右子树比左子树小，则孩子结点指向右子树
		//否则孩子结点任然指向左子树。
		//这里要特殊考虑到，左子树存在，但右子树不一定存在
		if (child+1<n && a[child] > a[child + 1])
		{
			child += 1;
		}

		//如果子树结点值小于父结点，则进行交换
		//父结点指向此时的子树
		if (a[child] < a[parent])
		{
			swap(a[child], a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

但是我们需要排序的数组，不可能每次都是左右子树恰好都是小根堆或者都是大根堆。
这个时候怎么办呢？建堆，没有堆，那么就自己造堆。

造堆

  造堆需要所有的子树都为大根堆或小根堆。那么从二叉树的末尾造堆是最好的选择，但是从末尾那个位置开始比较呢，从倒数第一个非叶子结点开始最好。

在这个二叉树中，最后的叶子结点本身就是大根堆或小根堆，所以高效的方法就是从倒数第一个非叶子结点开始。

造堆核心代码

	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		//n-1是最后一个叶子结点的下标
		// (n-1-1)/2 是最后一棵树的父节点
		AdjustSort(a, n, i);
	}

升序造大堆 向上调整

  基本思想是选择排序。
  如果建小堆，最小数在堆顶，已经被选出来了，那么要在剩下的数中在建一个堆，但是剩下的数据结构都乱了，需要重新新建一个堆。建堆的时间复杂度是o(N)，这样也不是不可以，但是这样堆排序就没有优势效率了。

  升序排序建大堆。
  第一个和最后一个交换，把最后一个数不看在堆里。
  前n-1个数向下调整（时间复杂度llog N向下调整二叉树的高度次）。
  选出次大的数，再和倒数第二个位置进行交换。

升序排序源代码

#include<iostream>
using namespace std;


void Print(int* a, int n)
{
	for (int i = 0; i < n; ++i)
	{
		cout << a[i] << " ";
	}
	cout << endl;
}

//向上调整
void upAdjustSort(int* a, int n, int root)
{
	//将父结点认为根结点
	int parent = root;
	//默认孩子为左孩子
	int child = parent * 2 + 1;
	//当父结点指向叶子结点的时候
	//孩子结点就会超出数组长度
	while (child<n)
	{
		//找出两个左右孩子中最大的结点
		//考虑极端情况，有左孩子但是没有右孩子
		if (child+1<n && a[child] < a[child + 1])
		{
			child += 1;
		}

		//孩子结点大于父结点，则进行交换
		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)
	{
		//向上调整
		upAdjustSort(a,n,i);
	}

	//开始排序
	int end = n - 1;
	while (end > 0)
	{
		//交换最大的数，和最后一个数的位置。
		swap(a[0], a[end]);
		upAdjustSort(a, end, 0);
		end--;
	}
}
void TestHeapSort()
{
	int arr[] = { 27,15,19,18,28,34,65,49,25,37 };
	HeapSort(arr, sizeof(arr) / sizeof(arr[0]));
	Print(arr, sizeof(arr) / sizeof(arr[0]));
}
int main()
{
	TestHeapSort();
	return 0;
}

降序造小堆 向下调整

  理解了升序，那么降序和升序相反即可。

#include<iostream>
using namespace std;


void Print(int* a, int n)
{
	for (int i = 0; i < n; ++i)
	{
		cout << a[i] << " ";
	}
	cout << endl;
}

//向下调整
void updownAdjustSort(int* a, int n, int root)
{
	//将父结点认为根结点
	int parent = root;
	//默认孩子为左孩子
	int child = parent * 2 + 1;
	//当父结点指向叶子结点的时候
	//孩子结点就会超出数组长度
	while (child<n)
	{
		//找出两个左右孩子中最小的结点
		//考虑极端情况，有左孩子但是没有右孩子
		if (child+1<n && a[child] > a[child + 1])
		{
			child += 1;
		}

		//孩子结点小于父结点，则进行交换
		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)
	{
		//向上调整
		updownAdjustSort(a,n,i);
	}

	//开始排序
	int end = n - 1;
	while (end > 0)
	{
		//交换最小的数，和最后一个数的位置。
		swap(a[0], a[end]);
		updownAdjustSort(a, end, 0);
		end--;
	}
}
void TestHeapSort()
{
	int arr[] = { 27,15,19,18,28,34,65,49,25,37 };
	HeapSort(arr, sizeof(arr) / sizeof(arr[0]));
	Print(arr, sizeof(arr) / sizeof(arr[0]));
}
int main()
{
	TestHeapSort();
	return 0;
}

运行结果

觉得我回答有用的话，记得点个关注哟！谢谢支持！