6.1: 二叉树的构建与遍历

最新推荐文章于 2024-08-18 17:28:15 发布

hxng

最新推荐文章于 2024-08-18 17:28:15 发布

阅读量128

点赞数

分类专栏：数据结构文章标签：数据结构

本文链接：https://blog.csdn.net/qq_74377018/article/details/130476646

版权

数据结构专栏收录该内容

13 篇文章 0 订阅

订阅专栏

二叉树基本概念

二叉树定义：

二叉树（Binary Tree）是n（n≥0）个节点所构成的集合，它或为空树（n=0），或为非空树。

对于非空树T:
（1）有且仅有一个称之为根的节点；
（2）除根节点以外的其余节点分为两个互不相交的子集T1和T2，分别称为T的左子树和右子树，且T1和T2本身又都是二叉树。

二叉树与树的区别

二叉树与树一样具有递归性质，二叉树与树的区别主要有以下两点：
（1）二叉树每个节点至多只有两棵子树（二叉树中不存在度大于2的节点）；
（2）二叉树的子树有左右之分，其次序不能任意颠倒。
二义树的递归定义表明二叉树或为空，或由一个根节点加上两棵分别称为左子树和右子树的、互不相交的二叉树组成。由于这两棵子树也是二叉树，则由二义树的定义，它们也可以是空树。

五种基本形态：

(a）空二叉树（b）仅有根结点的二叉树（c）右子树为空的二叉树（d）左、右子树均非空的二叉树（e）左子树为空的二叉树

代码：

初始化：

QueuePtr initQueue()
{
	QueuePtr resultQueuePtr = (QueuePtr)malloc(sizeof(struct BTNodePtrQueue));
	resultQueuePtr->nodePtrs = (BTNodePtr*)malloc(QUEUE_SIZE * sizeof(BTNodePtr));
	resultQueuePtr->front = 0;
	resultQueuePtr->rear = 1;
	return resultQueuePtr;
}

判断队列是否为空：

bool isQueueEmpty(QueuePtr paraQueuePtr)
{
	if ((paraQueuePtr->front + 1) % QUEUE_SIZE == paraQueuePtr->rear)
	{
		return true;
	}


	return false;
}

删除元素并返回：

BTNodePtr dequeue(QueuePtr paraQueuePtr)
{
	if (isQueueEmpty(paraQueuePtr))
	{
		printf("Error, empty queue\r\n");
		return NULL;
	}

	paraQueuePtr->front = (paraQueuePtr->front + 1) % QUEUE_SIZE;
	//BTNodePtr tempPtr = paraQueuePtr->nodePtrs[paraQueuePtr->front + 1];

	printf("dequeue %c ends.\r\n", paraQueuePtr->nodePtrs[paraQueuePtr->front]->element);
	return paraQueuePtr->nodePtrs[paraQueuePtr->front];
}

构造一个二叉树：

BTNodePtr stringToBTree(const char* paraString)
{
	int i;
	char ch;

	//使用队列管理指针
	QueuePtr tempQueuePtr = initQueue();

	BTNodePtr resultHeader;
	BTNodePtr tempParent, tempLeftChild, tempRightChild;
	i = 0;
	ch = paraString[i];
	resultHeader = constructBTNode(ch);
	enqueue(tempQueuePtr, resultHeader);

	while (!isQueueEmpty(tempQueuePtr))
	{
		tempParent = dequeue(tempQueuePtr);

		//左边的孩子
		i++;
		ch = paraString[i];
		if (ch == '#')
		{
			tempParent->left = NULL;
		}
		else
		{
			tempLeftChild = constructBTNode(ch);
			enqueue(tempQueuePtr, tempLeftChild);
			tempParent->left = tempLeftChild;
		}


		//右边的孩子
		i++;
		ch = paraString[i];
		if (ch == '#')
		{
			tempParent->right = NULL;
		}
		else
		{
			tempRightChild = constructBTNode(ch);
			enqueue(tempQueuePtr, tempRightChild);
			tempParent->right = tempRightChild;
		}
	}

	return resultHeader;
}

二叉树的遍历：

先序遍历：

若二叉树为空，则操作为空：否则
（1）访问根节点：（2）先序遍历左子树；（3）先序遍历右子树。

void preorder(BTNodePtr tempPtr)
{
	if (tempPtr == NULL)
	{
		return;
	}

	printf("%c", tempPtr->element);
	preorder(tempPtr->left);
	preorder(tempPtr->right);
}

中序遍历：

若二叉树为空，则操作为空；否则；
（1）中序遍历左子树（2）访问根节点；（3）中序遍历右子树。

二叉树每个节点，垂直方向投影下来，然后从左往右数，得出的结果便是中序遍历的结果

void inorder(BTNodePtr tempPtr)
{
	if (tempPtr == NULL)
	{
		return;
	}

	inorder(tempPtr->left);
	printf("%c", tempPtr->element);
	inorder(tempPtr->right);
}

后序遍历：

若二叉树为空，则操作为空；否则
（1）后序遍历左子树;（2）后序遍历右子树;（3）访问根节点

void postorder(BTNodePtr tempPtr)
{
	if (tempPtr == NULL)
	{
		return;
	}

	postorder(tempPtr->left);
	postorder(tempPtr->right);
	printf("%c", tempPtr->element);
}

总代码：

#include <stdio.h>
#include <malloc.h>

#define QUEUE_SIZE 5

//二叉树节点
typedef struct BTNode
{
	char element;
	BTNode* left;
	BTNode* right;
}BTNode, * BTNodePtr;

//具有多个指针的队列
typedef struct BTNodePtrQueue
{
	BTNodePtr* nodePtrs;
	int front;
	int rear;
}BTNodePtrQueue, * QueuePtr;

//初始化队列
QueuePtr initQueue()
{
	QueuePtr resultQueuePtr = (QueuePtr)malloc(sizeof(struct BTNodePtrQueue));
	resultQueuePtr->nodePtrs = (BTNodePtr*)malloc(QUEUE_SIZE * sizeof(BTNodePtr));
	resultQueuePtr->front = 0;
	resultQueuePtr->rear = 1;
	return resultQueuePtr;
}

//队列是否为空
bool isQueueEmpty(QueuePtr paraQueuePtr)
{
	if ((paraQueuePtr->front + 1) % QUEUE_SIZE == paraQueuePtr->rear)
	{
		return true;
	}


	return false;
}


//添加指向队列的指针
void enqueue(QueuePtr paraQueuePtr, BTNodePtr paraBTNodePtr)
{
	printf("front = %d, rear = %d.\r\n", paraQueuePtr->front, paraQueuePtr->rear);
	if ((paraQueuePtr->rear + 1) % QUEUE_SIZE == paraQueuePtr->front % QUEUE_SIZE)
	{
		printf("Error, trying to enqueue %c. queue full.\r\n", paraBTNodePtr->element);
		return;
	}

	paraQueuePtr->nodePtrs[paraQueuePtr->rear] = paraBTNodePtr;
	paraQueuePtr->rear = (paraQueuePtr->rear + 1) % QUEUE_SIZE;
	printf("enqueue %c ends.\r\n", paraBTNodePtr->element);
}

//从队列中删除一个元素并返回
BTNodePtr dequeue(QueuePtr paraQueuePtr)
{
	if (isQueueEmpty(paraQueuePtr))
	{
		printf("Error, empty queue\r\n");
		return NULL;
	}

	paraQueuePtr->front = (paraQueuePtr->front + 1) % QUEUE_SIZE;
	//BTNodePtr tempPtr = paraQueuePtr->nodePtrs[paraQueuePtr->front + 1];

	printf("dequeue %c ends.\r\n", paraQueuePtr->nodePtrs[paraQueuePtr->front]->element);
	return paraQueuePtr->nodePtrs[paraQueuePtr->front];
}

//使用给定的字符构造BTNode
BTNodePtr constructBTNode(char paraChar)
{
	BTNodePtr resultPtr = (BTNodePtr)malloc(sizeof(BTNode));
	resultPtr->element = paraChar;
	resultPtr->left = NULL;
	resultPtr->right = NULL;
	return resultPtr;
}

//使用给定的字符串构造一个二叉树
BTNodePtr stringToBTree(const char* paraString)
{
	int i;
	char ch;

	//使用队列管理指针
	QueuePtr tempQueuePtr = initQueue();

	BTNodePtr resultHeader;
	BTNodePtr tempParent, tempLeftChild, tempRightChild;
	i = 0;
	ch = paraString[i];
	resultHeader = constructBTNode(ch);
	enqueue(tempQueuePtr, resultHeader);

	while (!isQueueEmpty(tempQueuePtr))
	{
		tempParent = dequeue(tempQueuePtr);

		//左边的孩子
		i++;
		ch = paraString[i];
		if (ch == '#')
		{
			tempParent->left = NULL;
		}
		else
		{
			tempLeftChild = constructBTNode(ch);
			enqueue(tempQueuePtr, tempLeftChild);
			tempParent->left = tempLeftChild;
		}


		//右边的孩子
		i++;
		ch = paraString[i];
		if (ch == '#')
		{
			tempParent->right = NULL;
		}
		else
		{
			tempRightChild = constructBTNode(ch);
			enqueue(tempQueuePtr, tempRightChild);
			tempParent->right = tempRightChild;
		}
	}

	return resultHeader;
}

//水平方向
void levelwise(BTNodePtr paraTreePtr)
{
	//使用队列管理指针
	char tempString[100];
	int i = 0;
	QueuePtr tempQueuePtr = initQueue();
	BTNodePtr tempNodePtr;
	enqueue(tempQueuePtr, paraTreePtr);
	while (!isQueueEmpty(tempQueuePtr))
	{
		tempNodePtr = dequeue(tempQueuePtr);

		//用于输出
		tempString[i] = tempNodePtr->element;
		i++;

		if (tempNodePtr->left != NULL)
		{
			enqueue(tempQueuePtr, tempNodePtr->left);
		}

		if (tempNodePtr->right != NULL)
		{
			enqueue(tempQueuePtr, tempNodePtr->right);
		}
	}
	tempString[i] = '\0';

	printf("Levelwise: %s\r\n", tempString);
}

//先序
void preorder(BTNodePtr tempPtr)
{
	if (tempPtr == NULL)
	{
		return;
	}

	printf("%c", tempPtr->element);
	preorder(tempPtr->left);
	preorder(tempPtr->right);
}

//中序
void inorder(BTNodePtr tempPtr)
{
	if (tempPtr == NULL)
	{
		return;
	}

	inorder(tempPtr->left);
	printf("%c", tempPtr->element);
	inorder(tempPtr->right);
}

//后序
void postorder(BTNodePtr tempPtr)
{
	if (tempPtr == NULL)
	{
		return;
	}

	postorder(tempPtr->left);
	postorder(tempPtr->right);
	printf("%c", tempPtr->element);
}

//入口
int main()
{
	BTNodePtr tempHeader;
	tempHeader = constructBTNode('c');
	printf("There is only one node. Preorder visit: ");
	preorder(tempHeader);
	printf("\r\n");

	const char* tempString = "acde#bf######";

	tempHeader = stringToBTree(tempString);
	printf("Preorder: ");
	preorder(tempHeader);
	printf("\r\n");
	printf("Inorder: ");
	inorder(tempHeader);
	printf("\r\n");
	printf("Postorder: ");
	postorder(tempHeader);
	printf("\r\n");
	printf("Levelwise: ");
	levelwise(tempHeader);
	printf("\r\n");

	return 1;
}

结果：

hxng

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
6.1: 二叉树的构建与遍历

二叉树（Binary Tree）是n（n≥0）个节点所构成的集合，它或为空树（n=0），或为非空树。对于非空树T:（1）有且仅有一个称之为根的节点；（2）除根节点以外的其余节点分为两个互不相交的子集T1和T2，分别称为T的左子树和右子树，且T1和T2本身又都是二叉树。
复制链接

扫一扫

专栏目录