【数据结构入门】二叉树之堆排序及链式二叉树

前言

一、堆排序

1.概念

2.堆排序思想

3.具体步骤

4.实现

5.复杂度

二、堆的应用——TopK问题

三、链式二叉树

1.二叉树创建

2.二叉树遍历

1）前序、中序以及后序遍历

2）层序遍历

3.结点个数以及高度

1）结点个数：

2）结点高度

3）二叉树第K层结点的个数

4）查找值为x的结点

4. 判断二叉树是否为完全二叉树

5.二叉树的销毁

总结

前言

堆排序是一种使用堆数据结构的排序算法。堆是一种完全二叉树，且满足堆属性，即每个节点的值都大于（或小于）它的子节点的值。

二叉树的遍历有三种方式：前序遍历、中序遍历、后序遍历。这三种遍历方式都是深度优先遍历。

一、堆排序

1.概念

堆排序是一种基于堆数据结构实现的排序算法。它将待排序的序列构建成一个大顶堆（或小顶堆），然后依次取出堆顶元素，将其与最后一个元素交换位置，并不断调整堆使其重新满足堆的性质，最终得到一个有序的序列。

2.堆排序思想

堆排序即利用堆的思想来进行排序，总共分为两个步骤：

1. 建堆
升序：建大堆
降序：建小堆

注意：升序排列时，并不是建小堆，而是建大堆，堆排列都是从后往前排的，如果建小堆还需要多次交换数组。

建堆时可以使用向上调整也可以使用向下调整，但是向上调整的时间复杂度更高为Nlog(N)，而向下调整建堆的时间复杂度更低，为N，所以采用向下调整建堆。

2. 利用堆删除思想来进行排序

建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。

3.具体步骤

构建初始堆：将待排序序列构建成一个大顶堆。从最后一个非叶子节点开始，依次对每个节点进行调整，使其满足大顶堆的性质（父节点的值大于子节点的值）。
交换堆顶元素和最后一个元素：将堆顶元素与最后一个元素交换位置，并缩小堆的范围（即去掉最后一个元素）。
调整堆：对交换后的堆进行调整，使其重新满足大顶堆的性质。
重复步骤2和3，直到堆的范围缩小至1，即所有元素都已经排序完成。

4.实现

//左右子树都是大堆或者小堆
void ADjustDown(HPDataType* a, int sz, int parent)
{
	int child = parent * 2 + 1;
	while (child < sz)
	{
		//选出左右孩子中大的一个
		//这里child+1的判断在前，不要先访问再判断
		//这里a[child + 1] > a[child] 建大堆用>， 建小堆用<
		if (child + 1 < sz && a[child + 1] < a[child])
		{
			//这地方可能会越界
			++child;
		}
		//这里a[child] > a[parent] 建大堆用>， 建小堆用<
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}


void HeapSort(int* a, int sz)
{
	//1.建堆 -- 向上调整建堆   NlogN
	//左右子树必须是大堆/小堆
	/*for (int i = 1; i < sz; i++)
	{
		ADjustUp(a, i);
	}*/

	//2.向下调整建堆  N
	//左右子树必须是大堆/小堆
	for (int i = (sz - 1 -1) / 2; i >= 0; i--)
	{
		ADjustDown(a, sz, i);
	}

	int end = sz - 1;
	while (end > 0)
	{
		Swap(&a[end], &a[0]);
		ADjustDown(a, end, 0);
		--end;
	}
}

测试代码：

int main()
{
	int a[10] = { 2, 1, 5, 4, 7, 9, 8, 3, 6, 0};//对数组排序
	int sz = sizeof(a) / sizeof(a[0]);
	HeapSort(a, sz);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

测试结果：

5.复杂度

堆排序的时间复杂度为O(nlogn)，其中n为待排序序列的长度。堆排序是一种原地排序算法，不需要额外的存储空间，但由于堆的构建过程需要占用一定的空间，所以它并不是稳定的排序算法

二、堆的应用——TopK问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。

比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。

对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：

用数据集合中前K个元素来建堆
- 前k个最大的元素，则建小堆
- 前k个最小的元素，则建大堆
用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素

将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

typedef int HPDataType;


typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;


void ADjustDown(HPDataType* a, int sz, int parent)
{
	int child = parent * 2 + 1;
	while (child < sz)
	{
		//选出左右孩子中大的一个
		//这里child+1的判断在前，不要先访问再判断
		//这里a[child + 1] > a[child] 建大堆用>， 建小堆用<
		if (child + 1 < sz && a[child + 1] > a[child])
		{
			//这地方可能会越界
			++child;
		}
		//这里a[child] > a[parent] 建大堆用>， 建小堆用<
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void PrintTopk(const char* file, int k)
{
	//1.建堆 -- 用a中的前k个元素建小堆
	int* topk = (int*)malloc(sizeof(int) * k);
	assert(topk);

	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen error");
		return;
	}

	//读出前k个数据建小堆
	for (int i = 0; i < k; i++)
	{
		fscanf(fout, "%d", &topk[i]);
	}

	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		ADjustDown(topk, k, i);
	}

	//2.将剩余n-k个元素依次与堆顶元素交换，不满则替换
	int val = 0;
	int ret = fscanf(fout, "%d", &val);
	while (ret != EOF)
	{
		if (val > topk[0])
		{
			topk[0] = val;
			ADjustDown(topk, k, 0);
		}
		ret = fscanf(fout, "%d", &val);
	}

	for (int i = 0; i < k; i++)
	{
		printf("%d ", topk[i]);
	}
	printf("\n");


	free(topk);
	topk = NULL;
}

void CreatNData()
{
	//造数据
	int n = 10000;
	srand((unsigned int)time(0));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}

	for (size_t i = 0; i < n; ++i)
	{
		int x = rand() % 10000;
		fprintf(fin, "%d\n", x);
	}
	fclose(fin);
}

int main()
{
	// 在测试时可以先运行第一个函数，创造好数据，
	// 然后修改k条数据，再运行第二步，在监视窗口观察
	CreatNData();
	PrintTopk("data.txt", 10);
		
	return 0;
}

三、链式二叉树

只有完全二叉树的实现使用数组比较方便，因为很少造成空间浪费。其他二叉树使用链式结构更节省空间，但是由于链式二叉树的构造比较麻烦，所以这里只介绍链式二叉树的遍历。

1.二叉树创建

在操作二叉树前，需要创建一颗二叉树，这里为了简单直接手动创建一颗二叉树

typedef int BTDataType;

typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

BTNode* BuyNode(BTDataType x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		return NULL;
	}

	node->data = x;
	node->left = NULL;
	node->right = NULL;

	return node;
}

BTNode* CreatBinaryTree()
{
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);
	//BTNode* node7 = BuyNode(7);

	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;
	//node2->right = node7;

	return node1;
}

2.二叉树遍历

学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的结点进行相应的操作，并且每个结点只操作一次。访问结点所做的操作依赖于具体的应用问题。遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。

1）前序、中序以及后序遍历

按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：

前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。

前序遍历图示：

前序遍历实现：

void PreOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	printf("%d ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

前序遍历递归图示：

后序遍历实现：

void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}

	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}

后序遍历：

void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}

	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);
}

前序遍历结果：1 2 3 4 5 6

中序遍历结果：3 2 1 5 4 6

后序遍历结果：3 2 5 6 4 1

2）层序遍历

设二叉树的根结点所在层数为1，层序遍历就是从所在二叉树的根结点出发，首先访问第一层的树根结点，然后从左到右访问第2层上的结点，接着是第三层的结点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

层序遍历的实现可以借助队列，利用队列先进先出的特点，如果根不为空，就入队；如果左子树或右子树不为空就入队，直到队列为空。

void LevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root != NULL)
	{
		QueuePush(&q, root);
	}
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		printf("%d ", front->data);

		if (front->left)
		{
			QueuePush(&q, front->left);
		}
		if (front->right)
		{
			QueuePush(&q, front->right);
		}
	}
	printf("\n");
	QueueDestory(&q);
}

3.结点个数以及高度

1）结点个数：

注意：节点个数的返回，如果是要返回变量一定要注意，函数栈帧的会存储各自的变量，因此最好传入变量地址。

下面介绍不传变量的写法：

//分治思想
int TreeSize(BTNode* root)
{
	return root == NULL ? 0 :
		TreeSize(root->left) 
		+ TreeSize(root->right) 
		+ 1;
}

2）结点高度

要进行结点的递归比较时，存储变量值可以极大的提高效率

int TreeHeight(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	//记录数据，可以减少很多复杂度，提高效率
	int leftHeight = TreeHeight(root->left);
	int rightHeight = TreeHeight(root->right);

	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

3）二叉树第K层结点的个数

根结点为第一层

当前树的第k层个数=左子树的第k-1层个数 +左子树的第k-1层个数

int TreeLevelK(BTNode* root, int k)
{
	assert(k > 0);

	if (root == NULL)
	{
		return 0;
	}
	if (k == 1)
	{
		return 1;
	}
	return TreeLevelK(root->left, k - 1)+TreeLevelK(root->right, k - 1);

}

4）查找值为x的结点

BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
	{
		return NULL;
	}
	if (root->data == x)
	{
		return root;
	}
	BTNode* lret = BinaryTreeFind(root->left, x);
	if (lret)
	{
		return lret;
	}
	BTNode* rret = BinaryTreeFind(root->right, x);
	if (rret)
	{
		return rret;
	}
	//左右树都没有，返回空
	return NULL;
}

4. 判断二叉树是否为完全二叉树

完全二叉树按层序走，非空节点一定是连续的。

bool TreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	//为空则不入
	if (root)
	{
		QueuePush(&q, root);

	}
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);

		if (front == NULL)
		{
			break;
		}
		else
		{
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}

	}

	//判断是不是完全二叉树
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		//后面有非空，说明非空结点不是完全连续
		if (front)
		{
			QueueDestory(&q);
			return false;
		}
	}
	QueueDestory(&q);
	return true;
}

5.二叉树的销毁

采用后序遍历，不用存储根结点的位置。

void TreeDestory(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	TreeDestory(root->left);
	TreeDestory(root->right);
	free(root);
}

总结

堆排序的基本思想是先将待排序的序列构建成一个最大堆（或最小堆），然后将根节点与最后一个节点交换，再将剩下的 n-1 个节点重新构建成一个最大堆（或最小堆），如此循环，直到所有节点都被交换到适当的位置，从而得到一个有序序列。
前序遍历先访问根节点，然后递归地前序遍历左子树，再递归地前序遍历右子树。
中序遍历先递归地中序遍历左子树，然后访问根节点，再递归地中序遍历右子树。
后序遍历先递归地后序遍历左子树，然后递归地后序遍历右子树，最后访问根节点。
二叉树的遍历时间复杂度均为 O(n)，其中 n 是二叉树的节点数量。