二叉树的基本操作（C语言版）

最新推荐文章于 2024-10-17 23:18:04 发布

博兴666

最新推荐文章于 2024-10-17 23:18:04 发布

阅读量818

点赞数

本文链接：https://blog.csdn.net/BOXING666/article/details/81906148

版权

本文介绍了如何使用C语言实现二叉树的各种操作，包括创建、计算节点、叶节点、层节点、深度，查找节点，以及前序、中序、后序、层序遍历。还特别讲解了非递归的前序、中序和后序遍历方法，并针对后序遍历可能出现的死循环问题提出了解决方案。

摘要由CSDN通过智能技术生成

1.创建一个二叉树

思想：前序创建，VLR顺序，递归

int main()
{
       BTDataType arr[] = { 'A', 'B', 'D', '#', '#', 'G','#','#' ,'C', 'E', '#', '#', 'F'};
       int num = sizeof(arr) / sizeof(arr[0]);
       int i = 0;
}

//_arr为数组，num为元素个数，i为元素下标

BTNode* BuyNodeTree(BTDataType x)
{
	BTNode* newNode = (BTNode*)malloc(sizeof(BTNode));
	assert(newNode);
	newNode->_data = x;
	newNode->_left = NULL;
	newNode->_right = NULL;
	return newNode;
}

BTNode* BinaryTreeCreate(BTDataType* a, int num, int* i)  //前序，VLR
{
	if (a[*i] != '#'&& (*i)<num)
	{
		BTNode* root = BuyNodeTree(a[*i]);
		(*i)++;
		root->_left = BinaryTreeCreate(a, num, i);
		(*i)++;
		root->_right = BinaryTreeCreate(a, num, i);
		return root;
	}
	else
		return NULL;
}

2.计算树的节点

思想：左树的节点+右树的节点+1

int BinaryTreeNodeSize(BTNode* root)
{
	if (root == NULL)
		return 0;
	return BinaryTreeNodeSize(root->_left) + BinaryTreeNodeSize(root->_right) + 1;
}

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.计算树第K层的节点

思想：左树的第k-1层节点+右树的k-1层节点

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

5.计算树的深度

思想：先计算左树的深度，再计算右树的深度，最后返回大的

int BinaryTreeDepth(BTNode* root)                   //计算树的深度
{
	if (root == NULL)
		return 0;
	int _left = BinaryTreeDepth(root->_left) + 1;
	int _right = BinaryTreeDepth(root->_right) + 1;
	return _left > _right ? _left : _right;
}

6.查找结点

思想：先在左树中找，找到了，返回，否则，再在右树中找。都没有，返回空

BTNode* FindBinaryTreeNode(BTNode* root, BTDataType x)   //查找结点
{
	BTNode* _left;
	BTNode*  _right;
	if (root == NULL || root->_data == x)
		return root;
	_left = FindBinaryTreeNode(root->_left, x);
	if (_left)
		return _left;
	_right = FindBinaryTreeNode(root->_right, x);
	if (_right)
		return _right;
	return NULL;
}

7.前，中，后，序遍历

void BinaryTreePrevOrder(BTNode* root)                //前序遍历
{
	if (root == NULL)
		return;
	printf("%c ", root->_data);
	BinaryTreePrevOrder(root->_left);
	BinaryTreePrevOrder(root->_right);
}

void BinaryTreeInOrder(BTNode* root)					//中序遍历
{
	if (root == NULL)
		return;
	BinaryTreeInOrder(root->_left);
	printf("%c ", root->_data);
	BinaryTreeInOrder(root->_right);
}

void BinaryTreePostOrder(BTNode* root)					//后序遍历
{
	if (root == NULL)
		return;
	BinaryTreePostOrder(root->_left);
	BinaryTreePostOrder(root->_right);
	printf("%c ", root->_data);
}

8.层序遍历

思想：1.创建一个队列，先将根节点压进去

2.再判断其左树和右树节点是否为空，若不为空，就将这个节点的左树和右树节点压进去后，将这个节点pop掉

3.最后直到队列为空停止

void BinaryTreeLevelOrder(BTNode* root)				//层序遍历
{
	Queue q;
	QueueInit(&q);
	if (root == NULL)
		return;
	QueuePush(&q, root);
	while (QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		if (front->_left)
		{
			QueuePush(&q, front->_left);
		}
		if (front->_right)
		{
			QueuePush(&q, front->_right);
		}
		printf("%c ", front->_data);
		QueuePop(&q);
	}
}

9.判断是不是完全二叉树

思想：和层序遍历一样，只是把空指针也压了进去，一旦队列中遇到一个NULL,标记一下，若后边出现数据，则不是完全二叉树，若后边全部为空，则是完全二叉树

int BinaryTreeComplete(BTNode* root)                  //判断是不是完全二叉树
{
	int flag = 0;
	Queue q;
	QueueInit(&q);
	if (root == NULL)
		return 1;
	QueuePush(&q, root);
	while (QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		if (front != NULL)
		{
			if (flag == 1)
				return 0;
			QueuePush(&q, front->_left);
			QueuePush(&q, front->_right);
		}
		else
		{
			flag = 1;
		}
		QueuePop(&q);
	}
	return 1;
}

10.重点：

（1）前序遍历（非递归）

思想：1.创建一个栈，创建一个cur总指向一个树的根节点

2.当cur不为空时，直接访问，之后压栈；再访问它的左子树

3.当cur为空时，用top记住此时的栈顶，因为这是cur的双亲结点

4.再出栈，这时，判断top的右子树，即cur=top->right (化为子问题)

void BinaryTreePrevOrderNoD(BTNode* root)                //前序遍历非递归
{
	Stack s;
	StackInit(&s);
	BTNode* cur = root;                        //cur总指向一个树的根节点
	if (root == NULL)
	{
		printf("树为空！\n");
		return;
	}
	while (cur || StackEmpty(&s))
	{
		//先访问树的左树
		while (cur)
		{
			printf("%c ", cur->_data);
			StackPush(&s, cur);
			cur = cur->_left;
		}
		//cur为空，先pop掉，再访问top的右树
		BTNode* top = StackTop(&s);
		StackPop(&s);
		//子问题访问右树
		cur = top->_right;
	}
}

（2）中序遍历（非递归）

思想：1.创建一个栈，创建一个cur总指向一个树的根节点

2.当cur不为空时，先压栈；再访问它的左子树

3.当cur为空时，用top记住此时的栈顶，因为这是cur的双亲结点，此时再访问节点

4.再出栈，这时，判断top的右子树，即cur=top->right (化为子问题)

void BinaryTreeInOrderNoD(BTNode* root)					//中序遍历非递归
{
	Stack s;
	StackInit(&s);
	BTNode* cur = root;                        //cur总指向一个树的根节点
	if (root == NULL)
	{
		printf("树为空！\n");
		return;
	}
	while (cur || StackEmpty(&s))
	{
		//先入树的左节点
		while (cur)
		{
			StackPush(&s, cur);
			cur = cur->_left;
		}
		BTNode* top = StackTop(&s);
		printf("%c ", top->_data);
		StackPop(&s);
		cur = top->_right;
	}
}

（3）后序遍历（非递归）

思想：1.创建一个栈，创建一个cur总指向一个树的根节点

2.当cur不为空时，先压栈；再访问它的左子树

3.当cur为空时，用top记住此时的栈顶，因为这是cur的双亲结点

4.如果top->right为NULL,则直接访问top,否则cur=top->right (化为子问题)

问题：会导致死循环

解决办法：用一个prev指针标记上一次访问的节点，如果top->right和prev相等，则说明top的右子树访问过了，就可以访问top了

void BinaryTreePostOrderNoD(BTNode* root)					//后序遍历非递归
{
	BTNode* top;
	BTNode* prev=NULL;
	Stack s;
	StackInit(&s);
	BTNode* cur = root;                        //cur总指向一个树的根节点
	if (root == NULL)
	{
		printf("树为空！\n");
		return;
	}
	while (cur || StackEmpty(&s))
	{
		while (cur)
		{
			StackPush(&s, cur);
			cur = cur->_left;
		}
		//这里的cur始终为空
		top = StackTop(&s);
		if (top->_right == NULL||top->_right == prev)
		{
			printf("%c ", top->_data);
			prev = top;                     //标记上一次访问的节点,即访问根节点之前，要访问右树节点
			StackPop(&s);
		}
		else
		{
			cur = top->_right;
		}
	}
}