【数据结构】链式二叉树

---

一、二叉树的遍历

二叉树有四种遍历方式：前序、中序、后序和层序遍历。

• 前序遍历：先从根节点开始，然后再遍历左节点，之后才是右节点
• 中序遍历：先从左节点开始，然后再遍历根节点，之后才是右节点
• 后序遍历：先从左节点开始，然后再遍历右节点，之后才是根节点
• 层序遍历：就是一层一层遍历

举个例子：

前序遍历：1 2 3 4 5 6
中序遍历：3 2 1 5 4 6
后序遍历：3 2 5 6 4 1
层序遍历：1 2 4 3 5 6

代码实现：

/**
 * Definition for a binary tree node.
 * typedef struct BinaryTreeNode{
 *     int data;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * }BTNode;
 */

//前序遍历
void BinaryTreePrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	printf("%d ", root->data);
	BinaryTreePrevOrder(root->left);
	BinaryTreePrevOrder(root->right);
}
//中序遍历
void BinaryTreeInOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	BinaryTreeInOrder(root->left);
	printf("%d ", root->data);
	BinaryTreeInOrder(root->right);
}
//后序遍历
void BinaryTreePostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	BinaryTreePostOrder(root->left);
	BinaryTreePostOrder(root->right);
	printf("%d ", root->data);
}
//层序遍历
//层序遍历需要用到队列这个数据结构，我之前写过博客
//队列的特性是先进先出
//每出一个节点，就把它的左右节点进队列，这样就可以不断把二叉树给遍历完
void BinaryTreeLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
	{
		QueuePush(&q, root);
	}
	while (!QueueEmpty(&q))
	{
		//当队列不为空就出数据
		BTNode* front = QueueFront(&q);
		printf("%d ", front->data);
		QueuePop(&q);
		//把左右节点进队列
		if (front->left)
		{
			QueuePush(&q, front->left);
		}
		if (front->right)
		{
			QueuePush(&q, front->right);
		}
	}
	printf("\n");
	QueueDestroy(&q);
}

二、节点个数以及高度等

1. 节点个数

//通过递归求解节点个数
int BinaryTreeSize(BTNode* root)
{
	return root == NULL ? 0 : 
	BinaryTreeSize(root->left) +    
	 BinaryTreeSize(root->right) + 1;
}

2. 叶子个数

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

3. 二叉树第k层节点个数

假设k=4。
对于根节点来说，是第四层；对于第二层来说，是第三层；
对于第三层来说，是第二层；对于第四层来说，就是第一层。
所以通过递归，让看k不断的变小，直到k=1，就是我们所要找的第k层。

int BinaryTreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL)
	{
		return 0;
	}
	if (k == 1)
	{
		return 1;
	}
	return BinaryTreeLevelKSize(root->left, k - 1) +
		BinaryTreeLevelKSize(root->right, k - 1);
}

4. 二叉树高度

int BinaryTreeHeight(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	//接收返回值
	int leftHeight = BinaryTreeHeight(root->left);
	int rightHeight = BinaryTreeHeight(root->right);
	
	return leftHeight > rightHeight ? 
	      leftHeight + 1 : rightHeight + 1;
}

5. 二叉树查找值为x的节点

BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
	{
		return NULL;
	}
	if (root->data == x)
	{
		return root;
	}
	BTNode* ret1 = BinaryTreeFind(root->left, x);
	if (ret1)
	{
		return ret1;
	}
	BTNode* ret2 = BinaryTreeFind(root->right, x);
	if (ret2)
	{
		return ret2;
	}
	return NULL;
}

三、二叉树的创建和销毁

1. 二叉树遍历

二叉树遍历

//通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树

#include <stdio.h>
#include <stdlib.h>

struct TreeNode
{
    char val;
    struct TreeNode* left;
    struct TreeNode* right;
};
//这里之所以i传的是地址，是因为如果传i的话，i是形参，形参的改变不会影响实参
//在递归的过程中，函数的栈帧销毁后，原来的i已经也随之销毁了
//所以传i的地址，才能保证递归过程中，i是同一个i
 struct TreeNode* BuildTree(char* str, int* pi)
 {
    if(str[*pi] == '#')
    {
        (*pi)++;
        return NULL;
    }
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = str[(*pi)++];
    root->left = BuildTree(str, pi);
    root->right = BuildTree(str, pi);
    return root;
 }

 void Inorder(struct TreeNode* root)
 {
    if(root == NULL)
    {
        return;
    }
    Inorder(root->left);
    printf("%c ",root->val);
    Inorder(root->right);
 }

int main() {
    char str[100];
    scanf("%s",str);
    int i = 0;
    struct TreeNode* root = BuildTree(str, &i);
    Inorder(root);
    return 0;
}

2. 二叉树销毁

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

3. 判断二叉树是否是完全二叉树

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;
		}
		else
		{
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}
	}
	//然后判断，若后面都为空，则为完全二叉树；
	//若有一个不为空，就不是完全二叉树。
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		if (front != NULL)
		{
			QueueDestroy(&q);
			return false;
		}
	}
	QueueDestroy(&q);
	return true;
}

---