typedef int BTDataType;
// 二叉链
struct BinaryTreeNode
{
     struct BinTreeNode* left; // 指向当前结点左孩子
     struct BinTreeNode* right; // 指向当前结点右孩子
     BTDataType data; // 当前结点值域
}

// 三叉链
struct BinaryTreeNode
{
     struct BinTreeNode* parent; // 指向当前结点的双亲
     struct BinTreeNode* left; // 指向当前结点左孩子
     struct BinTreeNode* right; // 指向当前结点右孩子
     int data; // 当前结点值域
}；

前 k 个最大的元素，则建小堆

前 k 个最小的元素，则建大堆

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

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

	fclose(fin);
}
void TestHeap()
{
	int k;
	printf("请输入k>:");
	scanf("%d", &k);
	int* kminheap = (int*)malloc(sizeof(int) * k);
	if (kminheap == NULL)
	{
		perror("malloc fail");
		return;
	}
	const char* file = "data.txt";
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen error");
		return;
	}

	// 读取文件中前k个数
	for (int i = 0; i < k; i++)
	{
		fscanf(fout, "%d", &kminheap[i]);
	}
	// 建K个数的小堆
	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(kminheap, k, i);
	}
	// 读取剩下的N-K个数
	int x = 0;
	while (fscanf(fout, "%d", &x) > 0)//读取文件剩下的数据
	{
		if (x > kminheap[0])
		{
			kminheap[0] = x;
			AdjustDown(kminheap, k, 0);
		}
	}

	printf("最大前%d个数：", k);
	for (int i = 0; i < k; i++)
	{
		printf("%d ", kminheap[i]);
	}
	printf("\n");
}

int main()
{
	//创建数据
	CreateNDate();
	TestHeap();
	return 0;
}

void Postorde(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	Postorde(root->_left);
	Postorde(root->_right);
	printf("%d ", root->_data);
}

4.2.4层序遍历

每层每层遍历

遍历的结果就是1,2,3,4,5,6，而这种遍历则需要用到队列来实现，当把1放进队列，把1的左右节点放进队列，把1丢出，再把2和4的左右节点放进队列，把2,4丢出，重复如此，就完成了层序遍历

void LevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);//初始化队列
	if (root)
	{
		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);
		}
	}
	QueueDestroy(&q);//队列销毁
}

4.3基础接口实现

4.3.1二叉树结点个数

int size = 0;
int TreeSize(BTNode* root)
{
	if (root == NULL)
		return 0;
	else
		++size;

	TreeSize(root->_left);
	TreeSize(root->_right);
	return size;
}

对于这个程序，每次我们调用都要使size=0，我们可以优化一下

int TreeSize(BTNode* root)
{
	return root == NULL ? 0 :
		TreeSize(root->_left) + TreeSize(root->_right) + 1;
}

这个就相当于左子树的节点+右子树的节点+1（自己本身）

4.3.2二叉树的高度

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

	return TreeHeight(root->left) > TreeHeight(root->right) ?
		TreeHeight(root->left) + 1 : TreeHeight(root->right) + 1;
}

这个程序有一些效率问题，每次判断完后，还要进入递归，导致重复计算很多，效率很低，因此可以用一个变量来存储

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

4.3.3 二叉树叶子结点个数

int BinaryTreeLeafSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->_left == NULL && root->_right == NULL)//判断是否是叶子节点
	{
		return 1;
	}
	return BinaryTreeLeafSize(root->_left)+BinaryTreeLeafSize(root->_right);
    //递归左右子树

}

4.3.4 二叉树第k层结点个数

int BinaryTreeLevelKSize(BTNode* root, int k)//根节点为第一层
{
	if (k == 1)
	{
		return 1;
	}
	if (root == NULL)
	{
		return 0;
	}
	return BinaryTreeLevelKSize(root->_left, k - 1) +
		BinaryTreeLevelKSize(root->_right, k - 1);
    //递归左右子树
}

4.3.5 二叉树查找值为x的结点

BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root->_data == x)
	{
		return root;
	}
	BTNode* ret = BinaryTreeFind(root->_left, x);//存储结果
	if (ret)//当查到就返回
	{
		return ret;
	}
	return BinaryTreeFind(root->_right, x);
}

4.3.6 通过前序遍历的数组构建二叉树

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(char* a, int n, int* pi)//char*a代表要构建的数据 n代表a内的数据个数
{
	if (a[*pi] == '#')
	{
		(*pi)++;
		return NULL;
	}
	if (n == *pi)
	{
		return NULL;
	}
	BTNode* ret = (BTNode*)malloc(sizeof(BTNode));
	ret->_data = a[(*pi)++];
	ret->_left = BinaryTreeCreate(a,n,pi);
	ret->_right = BinaryTreeCreate(a,n,pi);
	return ret;
}

4.3.7 二叉树销毁

对于二叉树的销毁，要选择后序遍历，如果选择前中序遍历销毁，就无法找到所有节点

void BinaryTreeDestory(BTNode* root)
{
	if (root == NULL)
		return;
	TreeDestory(root->_left);
	TreeDestory(root->_right);
	free(root);
}

4.3.8 判断二叉树是否是完全二叉树

int BinaryTreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
	{
		QueuePush(&q, root);
	}
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		if (front == NULL)
		{
			break;
		}
		if (front->_left)
		{
			QueuePush(&q, front->_left);
		}
		if (front->_right)
		{
			QueuePush(&q, front->_right);
		}
	}
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);

		// 如果有非空，就不是完全二叉树
		if (front)
		{
			QueueDestroy(&q);
			return false;
		}
	}
	QueueDestroy(&q);
	return true;
}