数据结构 C 二叉树的构建与遍历

西欢乐

已于 2022-05-24 19:08:51 修改

阅读量773

点赞数

文章标签：数据结构 c语言 p2p

于 2022-05-24 17:15:39 首次发布

本文链接：https://blog.csdn.net/qq_66967137/article/details/124948337

版权

二叉树层次遍历完全二叉树队列遍历算法

关键词由CSDN通过智能技术生成

树与二叉树

注意：二叉树不是树！

二叉树结点的子树要区分左右子树，即便只有一颗子树也要说明是左还是右子树

二叉树的性质：

1.在二叉树的第k层上至多有个结点

2.深度为k的二叉树至多有个结点

3.对任何一颗二叉树，如果其终端结点数（叶子数）为，度为2的结点数为，则=+1；

满二叉树：深度为k且含有个结点的二叉树

完全二叉树：深度为k,有n个结点的二叉树，当且仅当其每一个都与深度为k的满二叉树中编号从1到n的结点一一对应，称为完全二叉树

4.具有n个结点的完全二叉树的深度为

二叉树的存储结构

顺序存储仅适合完全二叉树，其他类型适合用链式存储

1.二叉树的二叉链式存储表示

typedef struct BTNode{
   char element;
   struct BTNode* leftChild;
   struct BTNode* rightChild;
}BTNode,*BTNodePtr;

2.二叉树队列的表示

typedef struct BTNodeQueue{
   BTNodePtr* nodePtrs; //队列里存放的是二叉树结点的地址
   int front;
   int rear;
}BTNodeQueue,*BTNodeQueuePtr;

队列在二叉树中的使用

队列用于给定字符串的二叉树创建和层次遍历

3.二叉树队列的初始化(QueuePtr及其成员的空间分配及赋初值)

BTNodeQueuePtr initQueue(){
   BTNodeQueuePtr QueuePtr=(BTNodeQueuePtr)malloc(sizeof(struct BTNodeQueue));
   QueuePtr->nodePtrs=(BTNodePtr*)malloc(QUEUE_SIZE*sizeof(struct BTNode));//队列的空间用来存二叉树结点的地址
   QueuePtr->front=0;
   QueuePtr->rear=1;
   return QueuePtr;
}

图解：

4.判断是否队空（bool）

bool isQueueEmpty(BTNodeQueuePtr paraQueue){
   if((paraQueue->front+1)%QUEUE_SIZE==paraQueue->rear){
       return true;
   }
   return false;
}

5. 结点指针入队(传两个参数：QueuePtr、NodePtr)

void enqueue(BTNodeQueuePtr paraQueue,BTNodePtr paraBTNodePtr){
   //判断队列是否已满
   if((paraQueue->rear+1)%QUEUE_SIZE==paraQueue->front%QUEUE_SIZE){
       printf("The queue is full.Cannot enqueue data %c.\r\n",paraBTNodePtr->element);
   }
   //结点指针入队
   paraQueue->nodePtrs[paraQueue->rear]=paraBTNodePtr;
   paraQueue->rear=(paraQueue->rear+1)%QUEUE_SIZE;
   printf("%c has enqueued.\r\n",paraBTNodePtr->element);
}

6. 结点指针出队（传一参，返回值一个）

BTNodePtr dequeue(BTNodeQueuePtr paraQueue){
   //判断队列是否为空
   if(paraQueue->front==paraQueue->rear){
       printf("The queue is empty.Cannot dequeue element.\r\n");
       return NULL;
   }
   //结点指针出队
   paraQueue->front=(paraQueue->front+1)%QUEUE_SIZE;//front最初指向出队元素的前面的一个位置，现在让front指向出队指针
   printf("dequeue %c ends.\r\n",paraQueue->nodePtrs[paraQueue->front]->element);
   return paraQueue->nodePtrs[paraQueue->front];
}

二叉树的创建

7.创建二叉树结点（传一参，返回值一个）

BTNodePtr constructBTNode(char parachar){
   BTNodePtr tempNode=(BTNodePtr)malloc(sizeof(struct BTNode));
   tempNode->element=parachar;
   tempNode->leftChild=NULL;
   tempNode->rightChild=NULL;
   return tempNode;
}

8.用给定字符串创建二叉树（队列操作）

BTNodePtr stringToBTree(char* paraString){
   int i,ch;
   //初始化指针队列
   BTNodeQueuePtr tempQueue=initQueue();
   //头结点指针入队
   BTNodePtr Header,tempParent,tempLeftChild,tempRightChild;
   i=0;ch=paraString[i];Header=constructBTNode(ch);
   enqueue(tempQueue,Header);
   //创建子树
   while(!isQueueEmpty(tempQueue)){
       tempParent=dequeue(tempQueue);
       //leftchild
       i++;ch=paraString[i];
       if(ch=='#'){
           tempParent->leftChild=NULL;
       }else{
           tempLeftChild=constructBTNode(ch);
           enqueue(tempQueue,tempLeftChild);
           tempParent->leftChild=tempLeftChild;
       }
       //rightchild
       i++;ch=paraString[i];
       if(ch=='#'){
           tempParent->rightChild=NULL;
       }else{
           tempRightChild=constructBTNode(ch);
           enqueue(tempQueue,tempRightChild);
           tempParent->rightChild=tempRightChild;
       }
   }//Of while
   return Header;
}

图解：以字符串abcd#e为例

1.读入字符‘a’->创建根节点->根节点的指针入队（此处队列里的字母代表对应结点的地址）->rear由初始的1更新为2

2.进入while循环：根节点a出队->parent指向根节点->读入字符‘b’(不为'#'),创建新结点->b入队,rear由2更新为3

3.继续读入字符‘c’(不为‘#’),创建节点c->c结点入队（rear由3更新为4）

4.进入第二次while循环，parent指向出队结点b->读入字符‘d’,创建新节点d->d入队

二叉树的遍历

前序，中序，后序遍历：要用到递归（也可以不递归，此时需要用栈）

层序遍历：要用到队列

9.层次遍历（队列）（while循环）

void levelwise(BTNodePtr paraTreePtr){
   BTNodePtr tempNodePtr;//接受出队的结点指针
   int i=0;char tempString[100];//将结点的字符依次保存在字符串中，方便输出
   //初始化队列存储结点指针
   BTNodeQueuePtr tempQueue=initQueue();
   enqueue(tempQueue,paraTreePtr);
   while(!isQueueEmpty(tempQueue)){
       tempNodePtr=dequeue(tempQueue);
       tempString[i]=tempNodePtr->element;
       i++;
       if(tempNodePtr->leftChild!=NULL){
           enqueue(tempQueue,tempNodePtr->leftChild);
       }
       if(tempNodePtr->rightChild!=NULL){
           enqueue(tempQueue,tempNodePtr->rightChild);
       }
   }
   tempString[i]=='\0';
   printf("Levelwise:%s\r\n",tempString);
}

10.先序遍历（递归）

void preOrder(BTNodePtr tempPtr){
   if(tempPtr==NULL){
       return;
   }
   printf("%c",tempPtr->element);
   preOrder(tempPtr->leftChild);
   preOrder(tempPtr->rightChild);
}

11.中序遍历（递归）

void inOrder(BTNodePtr tempPtr){
   if(tempPtr==NULL){
       return;
   }
   inOrder(tempPtr->leftChild);
   printf("%c",tempPtr->element);
   inOrder(tempPtr->rightChild);
}

12.后序遍历（递归）

void poOrder(BTNodePtr tempPtr){
   if(tempPtr==NULL){
       return;
   }
   poOrder(tempPtr->leftChild);
   poOrder(tempPtr->rightChild);
   printf("%c",tempPtr->element);
}

完整代码

#include <stdio.h>
#include <malloc.h>
#include <stdbool.h>
#define QUEUE_SIZE 5//队列空间大小 
/*二叉树的二叉链式存储表示*/
typedef struct BTNode{
	char element;
	struct BTNode* leftChild;
	struct BTNode* rightChild;
}BTNode,*BTNodePtr;
/*二叉树队列的表示*/ 
typedef struct BTNodeQueue{
	BTNodePtr* nodePtrs; //队列里存放的是二叉树结点的地址
	int front;
	int rear; 
}BTNodeQueue,*BTNodeQueuePtr;
/*二叉树队列的初始化(QueuePtr及其成员的空间分配及赋初值)*/ 
BTNodeQueuePtr initQueue(){
	BTNodeQueuePtr QueuePtr=(BTNodeQueuePtr)malloc(sizeof(struct BTNodeQueue));
	QueuePtr->nodePtrs=(BTNodePtr*)malloc(QUEUE_SIZE*sizeof(struct BTNode));//队列的空间用来存二叉树结点的地址
	QueuePtr->front=0;
	QueuePtr->rear=1;
	return QueuePtr;
} 
/*判断是否队空（bool）*/
bool isQueueEmpty(BTNodeQueuePtr paraQueue){
	if((paraQueue->front+1)%QUEUE_SIZE==paraQueue->rear){
		return true;
	}
	return false;
}
/*结点指针入队(传两个参数：QueuePtr、NodePtr)*/
void enqueue(BTNodeQueuePtr paraQueue,BTNodePtr paraBTNodePtr){
	//判断队列是否已满
	if((paraQueue->rear+1)%QUEUE_SIZE==paraQueue->front%QUEUE_SIZE){
		printf("The queue is full.Cannot enqueue data %c.\r\n",paraBTNodePtr->element);
	} 
	//结点指针入队
	paraQueue->nodePtrs[paraQueue->rear]=paraBTNodePtr;
	paraQueue->rear=(paraQueue->rear+1)%QUEUE_SIZE; 
	printf("%c has enqueued.\r\n",paraBTNodePtr->element);
}
/*结点指针出队*/
BTNodePtr dequeue(BTNodeQueuePtr paraQueue){
	//判断队列是否为空
	if(paraQueue->front==paraQueue->rear){
		printf("The queue is empty.Cannot dequeue element.\r\n");
		return NULL;
	}
	//结点指针出队
	paraQueue->front=(paraQueue->front+1)%QUEUE_SIZE;//front最初指向出队元素的前面的一个位置，现在让front指向出队指针 
	printf("dequeue %c ends.\r\n",paraQueue->nodePtrs[paraQueue->front]->element);
	return paraQueue->nodePtrs[paraQueue->front]; 
}
/*创建二叉树结点*/
BTNodePtr constructBTNode(char parachar){
	BTNodePtr tempNode=(BTNodePtr)malloc(sizeof(struct BTNode));
	tempNode->element=parachar;
	tempNode->leftChild=NULL;
	tempNode->rightChild=NULL;
	return tempNode;
}
/*用给定字符串创建二叉树*/
BTNodePtr stringToBTree(char* paraString){
	int i,ch;
	//初始化指针队列 
	BTNodeQueuePtr tempQueue=initQueue();
	//头结点指针入队 
	BTNodePtr Header,tempParent,tempLeftChild,tempRightChild;
	i=0;ch=paraString[i];Header=constructBTNode(ch);
	enqueue(tempQueue,Header);
	//创建子树 
	while(!isQueueEmpty(tempQueue)){
		tempParent=dequeue(tempQueue);
		//leftchild 
		i++;ch=paraString[i];
		if(ch=='#'){
			tempParent->leftChild=NULL;
		}else{
			tempLeftChild=constructBTNode(ch);
			enqueue(tempQueue,tempLeftChild);
			tempParent->leftChild=tempLeftChild;
		}
		//rightchild
		i++;ch=paraString[i];
		if(ch=='#'){
			tempParent->rightChild=NULL;
		}else{
			tempRightChild=constructBTNode(ch);
			enqueue(tempQueue,tempRightChild);
			tempParent->rightChild=tempRightChild;
		}
	}//Of while
	return Header;
}
/*层次遍历（队列）（while循环）*/
void levelwise(BTNodePtr paraTreePtr){
	BTNodePtr tempNodePtr;//接受出队的结点指针 
	int i=0;char tempString[100];//将结点的字符依次保存在字符串中，方便输出 
	//初始化队列存储结点指针
	BTNodeQueuePtr tempQueue=initQueue();
	enqueue(tempQueue,paraTreePtr); 
	while(!isQueueEmpty(tempQueue)){
		tempNodePtr=dequeue(tempQueue);
		tempString[i]=tempNodePtr->element;
		i++;
		if(tempNodePtr->leftChild!=NULL){
			enqueue(tempQueue,tempNodePtr->leftChild);
		}
		if(tempNodePtr->rightChild!=NULL){
			enqueue(tempQueue,tempNodePtr->rightChild);
		}
	}
	tempString[i]=='\0';
	printf("Levelwise:%s\r\n",tempString);
} 
/*先序遍历（递归）*/
void preOrder(BTNodePtr tempPtr){
	if(tempPtr==NULL){
		return;
	} 
	printf("%c",tempPtr->element);
	preOrder(tempPtr->leftChild);
	preOrder(tempPtr->rightChild);
} 
/*中序遍历（递归）*/
void inOrder(BTNodePtr tempPtr){
	if(tempPtr==NULL){
		return;
	} 
	inOrder(tempPtr->leftChild);
	printf("%c",tempPtr->element);
	inOrder(tempPtr->rightChild);
}
/*后序遍历（递归）*/ 
void poOrder(BTNodePtr tempPtr){
	if(tempPtr==NULL){
		return;
	}
	poOrder(tempPtr->leftChild);
	poOrder(tempPtr->rightChild);
	printf("%c",tempPtr->element);
}
int main(){
	BTNodePtr tempHeader;//保存根节点 
	//单个字符 
	tempHeader=constructBTNode('c');
	printf("There is only one node.preOrder visit:\r\n");
	preOrder(tempHeader);
	printf("\r\n");
	//字符串
	printf("---- the stringToBTree begins. ----\r\n");
	char *tempString="acde#bf######";
	tempHeader=stringToBTree(tempString);
	printf("---- the stringToBTree ends. ----\r\n");
	printf("---- traversal begins, ----\r\n");
	printf("preOrder:");
	preOrder(tempHeader);
	printf("\r\n");
	printf("inOrder:");
	inOrder(tempHeader);
	printf("\r\n");
	printf("poOrder:");
	poOrder(tempHeader);
	printf("\r\n");
	printf("Levelwise：\r\n");
	levelwise(tempHeader);
	printf("---- traversal ends, ----\r\n");
	return 0; 
}

运行结果

There is only one node.preOrder visit:
c
---- the stringToBTree begins. ----
a has enqueued.
dequeue a ends.
c has enqueued.
d has enqueued.
dequeue c ends.
e has enqueued.
dequeue d ends.
b has enqueued.
f has enqueued.
dequeue e ends.
dequeue b ends.
dequeue f ends.
---- the stringToBTree ends. ----
---- traversal begins, ----
preOrder:acedbf
inOrder:ecabdf
poOrder:ecbfda
Levelwise：
a has enqueued.
dequeue a ends.
c has enqueued.
d has enqueued.
dequeue c ends.
e has enqueued.
dequeue d ends.
b has enqueued.
f has enqueued.
dequeue e ends.
dequeue b ends.
dequeue f ends.
Levelwise:acdebf
---- traversal ends, ----

--------------------------------
Process exited after 0.05514 seconds with return value 0
请按任意键继续. . .