数据结构初阶之二叉树（二）

这节主要讲topk问题和二叉树遍历的一些递归

Topk问题的三种思路

Topk问题就是从一堆数据（N个）中选出最大的前K个，也就是头部排名问题

思路1：全部堆排序(先建堆，后排序)，排序的时间复杂度是O(N*logN)

思路2：建立N个数的大堆，再执行Top/Pop操作k次，时间复杂度为O（N+k*logN）

思路3：假设N非常大，比如N是100亿，K是100，那么前两种思路就有问题了，这是海量数据问题。这里可以引出一点：注意一下估算能力，100亿个整数要占用多少空间？反过来问，1G能存多少字节，10亿左右，那么100亿整数就需要40G左右的空间。这里正确的解决方法就是：

1.前K个数建立小堆。

2.剩下的N-K个依次跟堆顶数据比较，如果比小堆的顶数据大，就替换小堆的顶数据进堆并向下调整。

完成以上两步后，对立面的K个数就是最大的K个数，时间复杂度为O(K+(N-K)*logK)，时间复杂度没有什么优势，但是空间复杂度大大优化了。

下面列思路三的代码：

void swap(int *p1,int *p2)
{
    int temp=*p1;
    *p1=*p2;
    *p2=temp;
}
 
//用向下调整算法建小堆
void AdjustDown(int *a,int n,int parent)
{
   	int child=parent*2+1; //左孩子，左孩子+1即为右孩子
    while(child= 0; --i)
	{
		AdjustDown(kMinHeap, k, i);
	}

	// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换
	for (int j = k; j < n; ++j)
	{
		if (a[j] > kMinHeap[0])
		{
			kMinHeap[0] = a[j];
			AdjustDown(kMinHeap, k, 0);
		}
	}

	for (int i = 0; i < k; ++i)
	{
		printf("%d ", kMinHeap[i]);
	}
	printf("\n");
}
//
void TestTopk()
{
	int n = 10000;
	int* a = (int*)malloc(sizeof(int)*n);
	srand(time(0));
	for (int i = 0; i < n; ++i)
	{
		a[i] = rand() % 1000000;
	}
	a[5] = 1000000 + 1;
	a[1231] = 1000000 + 2;
	a[531] = 1000000 + 3;
	a[5121] = 1000000 + 4;
	a[120] = 1000000 + 5;
	a[99] = 1000000 + 6;
	a[0] = 1000000 + 7;
	a[76] = 1000000 + 8;
	a[423] = 1000000 + 9;
	a[3144] = 1000000 + 10;
	PrintTopK(a, n, 10);
}

接下来就是学习搜索二叉树，AVL树的基础。

二叉树的遍历问题（引入递归问题）

三种遍历分别是前序遍历，中序遍历和后序遍历。

前：根，左，右

中：左，根，右

后：左，右，根

对于这样的一棵树：用三种遍历走一次，看看编译器是怎么访问的

前：1 2 3 # # # 4 5 # # 6 # #

中：# 3 # 2 # 1 # 5 # 4 # 6 #

后：# # 3 # 2 # #  5 # # 6 4 1

下面给出代码验证：

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

BTNode* BuyNode(BTDataType x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	assert(node);

	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);

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

	return node1;
}
//前序
void PreOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("# ");
		return;
	}

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

	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}
//后序
void PostOrder(BTNode* root) {
	if (root == NULL) {
		printf("# ");
		return;
	}

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

int main()
{
	BTNode* root = CreatBinaryTree();
	PreOrder(root);
	printf("\n");

	InOrder(root);
	printf("\n");

	PostOrder(root);
	printf("\n");

	return 0;
}

接下来写几个关于二叉树的接口函数

1.二叉树节点个数：这里有两种实现方式。

int count = 0;
void TreeSize1(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}

	++count;
	TreeSize1(root->left);
	TreeSize1(root->right);
}

int TreeSize2(BTNode* root)
{
	return root == NULL ? 0 :
		TreeSize2(root->left) + TreeSize2(root->right) + 1;
}

2.二叉树叶子个数

int TreeLeafSize(BTNode* root)
{
	if (root == NULL)
		return 0;

	if (root->left== NULL && root->right == NULL)
		return 1;

	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}

3.二叉树某一层有几个

int TreeKLevel(BTNode* root, int k)
{
	assert(k >= 1);
	if (root == NULL)
		return 0;

	if (k == 1)
		return 1;

	return TreeKLevel(root->left, k - 1)
		+ TreeKLevel(root->right, k - 1);
}

4.二叉树查找值为x的结点

BTNode* TreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
		return NULL;

	if (root->data == x)
		return root;

	BTNode* ret1 = TreeFind(root->left, x);
	if (ret1)
		return ret1;

	BTNode* ret2 = TreeFind(root->right, x);
	if (ret2)
		return ret2;

	return NULL;
}