利用队列实现二叉有序树的层次遍历

树和队列所需头文件

#ifndef	 	_TREEANDQUEUE_H_
#define 	_TREEANDQUEUE_H_

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

typedef int Elemtype;

typedef struct BiTNode
{

	Elemtype data;
	struct BiTNode* lchild;
	struct BiTNode* rchild;
	
}Bitnode;


typedef struct QNode
{

	Bitnode* data;
	struct QNode* next;
	
}Qnode;
typedef struct LinkedQueue
{

	Qnode* front;
	Qnode* rear;
	Qnode* num;
	
}Linkedqueue;

Linkedqueue* init_linkedqueue();
Qnode* init_qnode(Bitnode* value);
void enqueue(Linkedqueue* queue, Bitnode* value);
void dequeue(Linkedqueue* queue);
Bitnode* get_front(Linkedqueue* queue);
Linkedqueue* destory_queue(Linkedqueue* queue);
bool empty_queue(Linkedqueue* queue);

Bitnode* insert_node(Bitnode* root, Elemtype value);
Bitnode* creat_sort_tree();
void pre_order(Bitnode* root);
void mid_order(Bitnode* root);
void post_order(Bitnode* root);
void level_order(Bitnode* root);
Bitnode* delete_a_node(Bitnode* root,Elemtype value);

#endif

队列的实现

#include "treeandqueue.h"

Linkedqueue* init_linkedqueue()
{
	Linkedqueue* q = malloc(sizeof(Linkedqueue));

	q->front = NULL;
	q->rear = NULL;
	q->num = 0;
	
	return q;
	
}

Qnode* init_qnode(Bitnode* value)
{
	Qnode* q = malloc(sizeof(Qnode));

	q->data = value;
	q->next = NULL;

	return q;
}

void enqueue(Linkedqueue* queue, Bitnode* value)
{

	Qnode* p = init_qnode(value);
	
	if(queue->front == NULL)
	{
		queue->front = p;
		queue->rear = p;
	}
	else
	{
		queue->rear->next = p;
		queue->rear = p;
	}
	queue->num++;
}

void dequeue(Linkedqueue* queue)
{
	if(queue->num == 0)
	{
		printf("空队");
		return ;
	}

	if(queue->front->next == NULL)
	{
		Qnode* p = queue->front;
		queue->front = NULL;
		queue->rear = NULL;
		free(p);
	}
	else
	{
		Qnode* p =queue->front;
		queue->front = queue->front->next;
		p->next = NULL;
		free(p);
	}
	queue->num--;
}

Bitnode* get_front(Linkedqueue* queue)
{
	if(queue->num != 0)
		return  queue->front->data;
	else
		printf("队列已空，无法获取队头元素的数据\n");

	return NULL;
}

Linkedqueue* destory_queue(Linkedqueue* queue)
{
	Qnode* p = queue->front; //遍历整个队列
	Qnode* p_next = NULL;		//用来保存此时待删除结点的下一个结点的地址

	while(p != NULL)
	{
		p_next = p->next; //保存此时待删除结点的下一个结点的地址
		p->next = NULL;
		free(p);
		p = p_next;		//继续往后遍历
	}

	queue->front = NULL;
	queue->rear = NULL;
	queue->num = 0;
	free(queue);
	queue = NULL;

	return queue;
}

bool empty_queue(Linkedqueue* queue)
{
	if(queue->num == 0)
	{
		return true;
	}
	return false;
}

树的实现

层次遍历算法思路

step1: 把树的根结点入队

step2: 获取队头元素，并进行打印

step3: 判断当前队头元素是否存在左、右孩子。如果存在左、右孩子，则将其入队

step4: 出队

重复上面的过程2、3 、4步

#include "treeandqueue.h"

Bitnode* insert_node(Bitnode* root, Elemtype value)  //往树中插入元素，建立有序二叉树
{
	Bitnode* pnew = malloc(sizeof(Bitnode));
	
	pnew->data = value;
	pnew->lchild = NULL;
	pnew->rchild = NULL;

	Bitnode* p = root;
	
	if(root == NULL)
	{
		root = pnew;        
	}
	else
	{
		while(1)
		{
			if(p->data > value)      //插入元素比根结点小，插入到左子树中
			{
				if(p->lchild == NULL)        
				{
					p->lchild = pnew;
					break;
				}
				else
				{
					p = p->lchild;
				}
			}
			else if(p->data < value)    //插入元素比根结点大，插入到右子树中
			{
				if(p->rchild == NULL)
				{
					p->rchild = pnew;
					break;
				}
				else
				{
					p = p->rchild;
				}
			}
			else       //和根结点一样大，直接退出
			{
				break ;
			}
		}
	}
	return root;
}

Bitnode* creat_sort_tree()    	  //创建有序二叉树
{
	Elemtype value ;

	Bitnode* root = NULL;

	while(1)
	{
		scanf("%d",&value);
		if(value == 0)
		{
			break;
		}

		root = insert_node(root,value);
	}

	return root;
}


void pre_order(Bitnode* root)   //先序递归遍历
{
	if(root == NULL)
	{
		return;
	}
	printf("%d ",root->data);
	pre_order(root->lchild);
	pre_order(root->rchild);
}

void mid_order(Bitnode* root)  //中序递归遍历
{
	if(root == NULL)
	{
		return;
	}
	mid_order(root->lchild);
	printf("%d ",root->data);
	mid_order(root->rchild);
}

void post_order(Bitnode* root)  //后序递归遍历
{
	if(root == NULL)
		{
			return;
		}
	post_order(root->lchild);
	post_order(root->rchild);
	printf("%d ",root->data);

}

void level_order(Bitnode* root)  //树的层次遍历
{
	if(root == NULL)
	{
		return ;
	}
	
	Linkedqueue* queue = init_linkedqueue();   //建立一个空队
	enqueue(queue,root);      //将根结点压入到栈中
	Bitnode* p = NULL;    	  //用来遍历树
	
	while(!empty_queue(queue))   //队不为空，直到最后一个结点出队
	{
		
		p = get_front(queue);	 //获取队头元素，打印根结点的值
		printf("%d ",p->data);    
		
		if(p->lchild)
		{
			enqueue(queue,p->lchild);  //判断根结点的左孩子不为空，将其压入到队中
		}
		if(p->rchild)
		{
			enqueue(queue,p->rchild);	//判断根结点的右孩子不为空，将其压入到队中
		}
		
		dequeue(queue);   //将队头元素出队
	}
}

给孩子点点赞吧，谢谢你

主函数

#include "treeandqueue.h"


int main()
{
	Bitnode* root = creat_sort_tree();
	//root = delete_a_node(root,8);
	pre_order(root);
	printf("\n");
	mid_order(root);
	printf("\n");
	post_order(root);
	printf("\n");
	level_order(root);
}