二叉树(2)-二叉树链式结构的实现

1.二叉树的结构

typedef char BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;	//左孩子
	struct BinaryTreeNode* right;	//右孩子
}BTNode;

2. 二叉树的创建（简单）

BTNode* BuyBTNode(BTDataType x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	node->data = x;
	node->left = node->right = NULL;
	return node;
}

BTNode* BinaryTreeCreate()
{
	BTNode* n1 = BuyBTNode(1);
	BTNode* n2 = BuyBTNode(2);
	BTNode* n3 = BuyBTNode(3);
	BTNode* n4 = BuyBTNode(4);
	BTNode* n5 = BuyBTNode(5);
	BTNode* n6 = BuyBTNode(6);
	BTNode* n7 = BuyBTNode(4);
	n1->left = n2;
	n1->right = n4;
	n2->left = n3;
	n4->left = n5;
	n4->right = n6;
	n3->left = n7;
	return n1;
}

注意：上述代码并不是创建二叉树的方式，真正创建二叉树的方式后序讲解。

3.二叉树的三种遍历

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

• 1.前序遍历（先根遍历）：访问根节点的操作发生在遍历其左右子树之前。
• 2.中序遍历：访问根节点的操作发生在遍历其左右子树之中间。
• 3.后序遍历：访问根节点的操作发生在遍历其左右子树之后。
• 由于被访问的节点必是某子树的根，所以N、L、R又可解释为根、根的左子树、根的右子树。NLR、LNR、LRN分别又称为先根遍历、中根遍历和后根遍历。

3.1 前序遍历

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

3.2 中序遍历

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

3.3 后序遍历

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

3.4 层序遍历

层序遍历：除了前面三种遍历以外，还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第二层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的节点的过程就是层序遍历。

void LevelOrder(BTNode* root)
{
	Queue pq;
	QueueInit(&pq);
	int levelsize = 0;
	if (root)
	{
		QueuePush(&pq, root);
		levelsize = 1;
	}
	while (!QueueEmpty(&pq))
	{
		while (levelsize--)
		{
			BTNode* front = QueueFront(&pq);
			printf("%c ", front->data);
			QueuePop(&pq);
			if (front->left)
			{
				QueuePush(&pq, front->left);
			}
			if (front->right)
			{
				QueuePush(&pq, front->right);
			}
		}
		printf("\n");
		levelsize = QueueSize(&pq);
	}
	printf("\n");
	QueueDestroy(&pq);
}

4. 二叉树节点个数

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

5.二叉树叶子节点个数

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

6.二叉树高度

int TreeHeight(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	else
	{
		int leftH = TreeHeight(root->left);
		int rightH = TreeHeight(root->right);
		return leftH > rightH ? leftH + 1 : rightH + 1;
	}
}

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

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

8.二叉树查找值为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->left, x);
	if (ret2)
	{
		return ret2;
	}
	return NULL;
}

9.二叉树创建和销毁

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

BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
	if (a[*pi] == '#')
	{
		(*pi)++;
		return NULL;
	}
	BTNode* node = BuyBTNode(a[(*pi)++]);
	node->left = BinaryTreeCreate(a, n, pi);
	node->right = BinaryTreeCreate(a, n, pi);
	return node;
}

二叉树的销毁

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

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

运用层序遍历

bool BinaryTreeComplete(BTNode* root)
{
	Queue pq;
	QueueInit(&pq);
	if (root)
	{
		QueuePush(&pq, root);
	}
	while (!QueueEmpty(&pq))
	{
		BTNode* front = QueueFront(&pq);
		QueuePop(&pq);
		if (front == NULL)
		{
			break;
		}
		else
		{
			QueuePush(&pq, front->left);
			QueuePush(&pq, front->right);
		}
	}
	while (!QueueEmpty(&pq))
	{
		BTNode* front = QueueFront(&pq);
		QueuePop(&pq);
		if (front != NULL)
		{
			QueueDestroy(&pq);
			return false;
		}
	}
	QueueDestroy(&pq);
	return true;
}