二叉树的创建，及遍历 操作

最新推荐文章于 2024-02-11 15:56:42 发布
最新推荐文章于 2024-02-11 15:56:42 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： 【编程之美】 数据结构与算法 文章标签： 二叉树 遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014634338/article/details/38590113
版权

递归创建二叉树

利用括号嵌套的字符串建立二叉链表(递归，与非递归)

先序遍历二叉树的递归实现

中序遍历二叉树的递归实现

后序遍历二叉树的递归实现

先序遍历二叉树的非递归实现

中序遍历二叉树的非递归实现

后序遍历二叉树的非递归实现

二叉树的层次遍历

销毁二叉树操作

二叉树的左插入操作

二叉树的右插入操作

查找元素值为e的结点的指针

返回二叉树的左右孩子结点元素值操作

二叉树的左（右）删除操作

计算二叉树的深度，叶子节点个数

#include <iostream>
#include <string.h>
#include <stdio.h>
typedef char DataType;
#define MaxSize 100
using namespace std;
typedef struct Node				//二叉链表存储结构类型定义
{
	DataType data;			 	//数据域
	struct Node *lchild; 			//指向左孩子结点
	struct Node *rchild; 			//指向右孩子结点
}*BiTree,BitNode;


void InitBitTree(BiTree *T)
//二叉树的初始化操作
{
	*T=NULL;
}

void DestroyBitTree(BiTree *T)
//销毁二叉树操作
{
	if(*T) 							//如果是非空二叉树
	{
		if((*T)->lchild)
			DestroyBitTree(&((*T)->lchild));
		if((*T)->rchild)
			DestroyBitTree(&((*T)->rchild));
		free(*T);
		*T=NULL;
	}
}
void CreateBitTree(BiTree *T)
//递归创建二叉树
{
    DataType ch;
    scanf("%c",&ch);
    if(ch=='#')
        *T=NULL;
    else
    {
        *T=(BiTree)malloc(sizeof(BitNode)); 		//生成根结点
        if(!(*T))
        {
            exit(-1);
        }
        (*T)->data=ch;
        CreateBitTree(&((*T)->lchild)); 			//构造左子树
        CreateBitTree(&((*T)->rchild)); 			//构造右子树
    }
}
int InsertLeftChild(BiTree p,BiTree c)
//二叉树的左插入操作
{
    if(p) 									//如果指针p不空
    {
        c->rchild=p->lchild; 					//p的原来的左子树成为c的右子树
        p->lchild=c; 						//子树c作为p的左子树
        return 1;
    }
    return 0;
}
int InsertRightChild(BiTree p,BiTree c)
//二叉树的右插入操作
{
	if(p) 									//如果指针p不空
    {
        c->rchild=p->rchild; 					//p的原来的右子树作为c的右子树
        p->rchild=c; 						//子树c作为p的右子树
        return 1;
    }
    return 0;
}
BiTree Point(BiTree T,DataType e)
//查找元素值为e的结点的指针
{
	BiTree Q[MaxSize]; 			//定义一个队列，用于存放二叉树中结点的指针
	int front=0,rear=0; 			//初始化队列
    BitNode *p;
    if(T) 						//如果二叉树非空
    {
        Q[rear]=T;
        rear++;
		
        while(front!=rear) 		//如果队列非空
        {
            p=Q[front]; 			//取出队头指针
            front++;			//将队头指针出队
            if(p->data==e)
				return p;
            if(p->lchild) 			//如果左孩子结点存在，将左孩子指针入队
            {
                Q[rear]=p->lchild;	//左孩子结点的指针入队
                rear++;
            }
            if(p->rchild)			//如果右孩子结点存在，将右孩子指针入队
            {
                Q[rear]=p->rchild; //右孩子结点的指针入队
                rear++;
            }
		}
    }
    return NULL;
}
DataType LeftChild(BiTree T,DataType e)
//返回二叉树的左孩子结点元素值操作
{
    BiTree p;
    if(T)										//如果二叉树不空
    {
        p=Point(T,e); 							//p是元素值e的结点的指针
        if(p&&p->lchild)							//如果p不为空且p的左孩子结点存在
            return p->lchild->data; 					//返回p的左孩子结点的元素值
    }
    return 0;
}
DataType RightChild(BiTree T,DataType e)
//返回二叉树的右孩子结点元素值操作
{
    BiTree p;
    if(T)										//如果二叉树不空
    {
        p=Point(T,e); 							//p是元素值e的结点的指针
        if(p&&p->rchild)							//如果p不为空且p的右孩子结点存在
            return p->rchild->data; 				//返回p的右孩子结点的元素值
    }
    return 0;
}
int DeleteLeftChild(BiTree p)
//二叉树的左删除操作
{
    if(p) 										//如果p不空
    {
        DestroyBitTree(&(p->lchild)); 				//删除左子树
        return 1;
    }
    return 0;
}
int DeleteRightChild(BiTree p)
//二叉树的左删除操作
{
    if(p) 										//如果p不空
    {
        DestroyBitTree(&(p->rchild)); 				//删除右子树
        return 1;
    }
    return 0;
    
}
void Queue(BiTree T)
{
    BiTree queue[100];
    BiTree p;
    int front=0,rear=0;
    if(T==NULL)
    {
        return;
    }
    queue[rear++]=T;
    while (front!=rear)
    {
        p=queue[front++];
        printf("%c ",p->data);
        if(p->lchild)
        {
            queue[rear++]=p->lchild;
        }
        if(p->rchild)
        {
            queue[rear++]=p->rchild;
        }
    }
}
//函数的声明
void PreOrderTraverse(BiTree T);	//二叉树的先序遍历的递归函数声明
void InOrderTraverse(BiTree T);		//二叉树的中序遍历的递归函数声明
void PostOrderTraverse(BiTree T);	//二叉树的后序遍历的递归函数声明
void PreOrderTraverse2(BiTree T);	//二叉树的先序遍历的非递归函数声明
void InOrderTraverse2(BiTree T);	//二叉树的中序遍历的非递归函数声明
void PostOrderTraverse2(BiTree T);	//二叉树的后序遍历的非递归函数声明
void CreateBitTree2(BiTree *T,char str[]);	//利用括号嵌套的字符串建立二叉树的函数声明
void QueueTraverse(BiTree T);       //二叉树的层次序遍历函数声明
int GetHeight(BiTree T);            //二叉树深度函数声明
int CountLeaf(BiTree T);            //二叉树叶子结点个数函数声明
int NotLeafCount(BiTree T);         //统计二叉树中非叶子结点数目
int main()
{
    char str[]="A(B(D(,H(J,)),E(,I)),C(F,G))";
	BiTree T,root;
	InitBitTree(&T);
	printf("根据输入二叉树的先序序列创建二叉树('#'表示结束)：\n");
	CreateBitTree(&T);
	printf("二叉树的先序序列：\n");
	printf("递归：\t");
	PreOrderTraverse(T);
	printf("\n");
	printf("非递归：");
	PreOrderTraverse2(T);
	printf("\n");
	printf("二叉树的中序序列：\n");
	printf("递归：\t");
	InOrderTraverse(T);
	printf("\n");
	printf("非递归：");
	InOrderTraverse2(T);
	printf("\n");
	printf("二叉树的后序序列：\n");
	printf("递归：\t");
	PostOrderTraverse(T);
	printf("\n");
	printf("非递归：");
	PostOrderTraverse2(T);
	printf("\n");
	printf("根据括号嵌套的字符串建立二叉树:\n");
	CreateBitTree2(&root,str);
	printf("二叉树的先序序列：\n");
	PreOrderTraverse(root);
	printf("\n");
	printf("二叉树的中序序列：\n");
	InOrderTraverse(root);
	printf("\n");
	printf("二叉树的后序序列：\n");
	PostOrderTraverse(root);
	printf("\n");
    printf("二叉树的层次遍历序列：\n");
    QueueTraverse(root);
    printf("\n");
    printf("二叉树的深度：\n");
    printf("%2d\n",GetHeight(root));
    printf("二叉树叶子结点个数：\n");
    printf("%2d\n",CountLeaf(root));
	printf("非叶子结点个数:\n%2d\n",NotLeafCount(root));
	DestroyBitTree(&T);
	DestroyBitTree(&root);
    return 0;
}

void  CreateBitTree2(BiTree *T,char str[])
//利用括号嵌套的字符串建立二叉链表
{
	char ch;
	BiTree stack[MaxSize];			//定义栈，用于存放指向二叉树中结点的指针
	int top=-1;						//初始化栈顶指针
	int flag=-1,k;
	BitNode *p=NULL;
	*T=NULL,k=0;
	ch=str[k];
	while(ch!='\0')					//如果字符串没有结束
	{
		switch(ch)
		{
            case '(':
                stack[++top]=p;
                flag=1;
                break;
            case ')':
                top--;
                break;
            case ',':
                flag=2;
                break;
            default:
                p=(BiTree)malloc(sizeof(BitNode));
                p->data=ch;
                p->lchild=NULL;
                p->rchild=NULL;
                if(*T==NULL)		//如果是第一个结点，表示是根结点
                    *T=p;
                else
                {
                    switch(flag)
                    {
                        case 1:
                            stack[top]->lchild=p;
                            break;
                        case 2:
                            stack[top]->rchild=p;
                            break;
                    }
                }
		}
		ch=str[++k];
	}
	
}
void PreOrderTraverse(BiTree T)
//先序遍历二叉树的递归实现
{
    if(T)								//如果二叉树不为空
    {
        printf("%2c",T->data); 				//访问根结点
        PreOrderTraverse(T->lchild);		//先序遍历左子树
        PreOrderTraverse(T->rchild); 		//先序遍历右子树
    }
}
void InOrderTraverse(BiTree T)
//中序遍历二叉树的递归实现
{
    if(T)								//如果二叉树不为空
	{
		InOrderTraverse(T->lchild);			//中序遍历左子树
        printf("%2c",T->data); 				//访问根结点
        InOrderTraverse(T->rchild); 		//中序遍历右子树
    }
}
void PostOrderTraverse(BiTree T)
//后序遍历二叉树的递归实现
{
    if(T)								//如果二叉树不为空
	{
		PostOrderTraverse(T->lchild);		//后序遍历左子树
        PostOrderTraverse(T->rchild); 		//后序遍历右子树
		printf("%2c",T->data); 				//访问根结点
    }
}

void PreOrderTraverse2(BiTree T)
//先序遍历二叉树的非递归实现
{
	BiTree stack[MaxSize]; 				//定义一个栈，用于存放结点的指针
	int top; 							//定义栈顶指针
	BitNode *p; 						//定义一个结点的指针
	top=0;							//初始化栈
	p=T;
	while(p!=NULL||top>0)
	{
		while(p!=NULL) 					//如果p不空，访问根结点，遍历左子树
		{
			printf("%2c",p->data); 			//访问根结点
			stack[top++]=p; 				//将p入栈
			p=p->lchild; 				//遍历左子树
		}
		if(top>0) 						//如果栈不空
		{
			p=stack[--top]; 				//栈顶元素出栈
			p=p->rchild;					//遍历右子树
		}
	}
}
void InOrderTraverse2(BiTree T)
//中序遍历二叉树的非递归实现
{
	BiTree stack[MaxSize]; 				//定义一个栈，用于存放结点的指针
	int top; 							//定义栈顶指针
	BitNode *p; 						//定义一个结点的指针
	top=0;							//初始化栈
	p=T;
	while(p!=NULL||top>0)
	{
		while(p!=NULL) 					//如果p不空，访问根结点，遍历左子树
		{
			stack[top++]=p; 				//将p入栈
			p=p->lchild; 				//遍历左子树
		}
		if(top>0) 						//如果栈不空
		{
			p=stack[--top]; 				//栈顶元素出栈
			printf("%2c",p->data); 			//访问根结点
			p=p->rchild;					//遍历右子树
		}
	}
}

void PostOrderTraverse2(BiTree T)
//后序遍历二叉树的非递归实现
{
	BiTree stack[MaxSize]; 				//定义一个栈，用于存放结点的指针
	int top; 							//定义栈顶指针
	BitNode *p,*q; 						//定义结点的指针
	top=0;								//初始化栈
	p=T,q=NULL; 						//初始化结点的指针
	while(p!=NULL||top>0)
	{
		while(p!=NULL) 						//如果p不空，访问根结点，遍历左子树
		{
			stack[top++]=p; 				//将p入栈
			p=p->lchild; 					//遍历左子树
		}
		if(top>0) 							//如果栈不空
		{
			p=stack[top-1]; 					//取栈顶元素
			if(p->rchild==NULL||p->rchild==q) 	//如果p没有右孩子结点，或右孩子结点已经访问过
			{
				printf("%2c",p->data); 			//访问根结点
				q=p;
				p=NULL;
				top--;
			}
			else
				p=p->rchild;
		}
	}
}
void QueueTraverse(BiTree T)
{
    BiTree queue[MaxSize];                   //定义一个队列，用于存放结点的指针
    int front=-1,rear=-1;                      //定义队列头，尾指针
    BiTree p;
    if(T==NULL)
    {
        return;
    }
    rear=(rear+1)%MaxSize;
    queue[rear]=T;                        //如果根结点不为空，则根结点先入队列
    while (front!=rear)
    {
        front=(front+1)%MaxSize;
        p=queue[front];                   //如果队列不为空，则出队一个节点
        printf("%2c",p->data);
        if(p->lchild)
        {
            rear=(rear+1)%MaxSize;
            queue[rear]=p->lchild;        //当前结点的左孩子不为空则入队
        }
        if(p->rchild)
        {
            rear=(rear+1)%MaxSize;
            queue[rear]=p->rchild;        //当前结点的右孩子不为空则入队
        }
    }
}
int GetHeight(BiTree T)
{
    int lh,rh;
    if(T==NULL)
    {
        return 0;                            //空树，深度0
    }
    lh=GetHeight(T->lchild);                 //递归调用获得左子树的深度
    rh=GetHeight(T->rchild);                 //递归调用获得右子树的深度
    if(lh>=rh)                               //取左右字树深度最大者，作为字树的深度，这个树的深度是字树深度加1
    {
        return lh+1;
    }
    return rh+1;
}
int CountLeaf(BiTree T)
{
    int lnum,rnum;
    if(T==NULL)
    {
        return 0;
    }
    lnum=CountLeaf(T->lchild);     //递归求左子树叶子结点个数
    rnum=CountLeaf(T->rchild);     //递归求右子树叶子结点个数
    if(lnum+rnum==0)
    {
        return 1;                  //如果左右字树叶子的和为0，说明是叶子结点返回1，否则返回左右子树叶子结点的和
    }
    else
    {
        return lnum+rnum;
    }
}
int NotLeafCount(BiTree T)
{
    if(T==NULL)
    {
        return 0;
    }
    if(!T->rchild && !T->lchild)    //如果是叶子结点，返回0
    {
        return 0;
    }
    return NotLeafCount(T->lchild)+NotLeafCount(T->rchild)+1;     //左右子树的非叶子结点数目加上根结点的个数
}

根据括号方式递归创建二叉树：

#include <iostream>
using namespace std;
struct BTree
{
    char ch;
    BTree *lchild,*rchild;
    BTree()
    {
        lchild=rchild=NULL;
    }
};
void PreOrder(BTree *root)
{
    if(root==NULL)
    {
        return;
    }
    printf("%c ",root->ch);
    PreOrder(root->lchild);
    PreOrder(root->rchild);
}

void PostOrder(BTree *root)
{
    if(root==NULL)
    {
        return;
    }
    
    PostOrder(root->lchild);
    PostOrder(root->rchild);
    printf("%c ",root->ch);
}
int cnt;
void CreatBinaryTree(BTree *&root,char *str)
{
    if(str[cnt]>='a' && str[cnt]<='z')//创建结点
    {
        root=new BTree;
        root->ch=str[cnt++];
    }
    if(str[cnt]=='(') //准备创建左右孩子
    {
        cnt++;
        CreatBinaryTree(root->lchild, str);
        CreatBinaryTree(root->rchild, str);
        
    }
    if(str[cnt]==',') //右子树创建完毕，返回
    {
        cnt++;
        return;
    }
    if(str[cnt]==')') //左右子树创建完毕，返回
    {
        cnt++;
        return;
    }
    
}
int main()
{
    BTree *root;
    cnt=0;
    char str[]="a(b(c,d),e(f,g))";
    char str2[]="a(b(d,e(h,)),c(f(,i),g(j,k)))";
    CreatBinaryTree(root, str2);
    PreOrder(root);
    printf("\n");
    PostOrder(root);
}



zthgreat
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
队列的概念及其用法
沐 白
09-15 639
队列的概念及其用法
第5章 树和二叉树
sdjcwangwei的博客
11-03 167
树的遍历操作 前序遍历 若树为空，则空操作返回；否则执行以下操作： 访问根节点； 按照从左到右的顺序从左到右的顺序前序遍历根节点的每一颗子树。 后序遍历 若树为空，则空操作返回；否则执行以下操作： 按照从左到右的顺序后序遍历根节点的每一颗子树 访问根节点 层序遍历 从树的根节点开始，自上而下逐层遍历，在同一层中，按从左到右的顺序对节点逐个访问 树的存储结构 双亲表示法 除根节点外，树中的每个节点有...
【数据结构】二叉树的层次遍历
暗星涌动
06-25 241
在上一篇文章【数据结构】二叉树的中序遍历 中我们学会了前中后序遍历，并着重讲述了中序遍历的思路及其实现代码（1 + 2），今天我们讲一讲二叉树的层次遍历。层次遍历，顾名思义，就是按层...
【队列】队列的基本操作总结
为了远大的理想，冲锋！
08-06 788
目录 queue的常见用法 priority_queue的常见用法 队列是一种先进先出的数据结构，通常用一个队首元素front指向队首元素的前一个位置，而使用队尾指针来指向队尾元素。 清空(clear)： /*使用数组来实现队列是，初始状态为front=-1，rear=-1*/ void clear(){ front=rear=-1; } 获得队列中的元素个数(...
循环队列的探索
若砚的博客
04-09 322
public class CyclicQ3 { static int[] queue = new int[9]; static int front = 0; static int rear = 0; static void insert(int key) { if ((rear + 1) % 9 == front) { queue[rear % 9] = key;
线索二叉树的创建和操作
tnxlcn的博客
01-27 478
线索二叉树可以不通过栈就能实现二叉树的遍历 指向前驱和后继的指针称为线索，加上线索的二叉链表就称为线索链表，相应的二叉树就称为线索二叉树 对二叉树以某种次序遍历，使其成为线索二叉树的过程就叫做线索化 #include&lt;iostream&gt; /* 线索二叉树可以不通过栈就能实现二叉树的遍历 */ typedef char Elemtype; typedef struct Thre...
二叉树的遍历及创建
最新发布
2302_80873119的博客
02-11 814
二叉树遍历及创建
数据结构-二叉树的建立及遍历操作
05-23
数据结构-二叉树的建立及遍历操作
数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。
07-01
数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。 数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。 数据结构实用教程之二叉树，...
数据结构试验3二叉树建立，遍历等
11-11
数据结构试验3二叉树建立，遍历等操作代码及运行结果。 实验内容： 采用二叉链表存储，实现二叉树的创建、遍历（递归）、赫夫曼编码和译码等典型操作。 1. 编程实现如下功能： （1）假设二叉树的结点值是字符型，...
二叉树建立及其遍历
11-26
C实现二叉树的建立及先中后序的遍历，控制台程序，在各版本vs上均可运行
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
数据结构之队列
kingyal
08-15 689
       队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，在表的后端（rear）进行插入操作，进行插入的一端称为队尾，进行删除的一端称为对头或队首。常用的队列有顺序队列，循环队列等。 顺序队列：建立顺序队列结构必须为其静态分配或动态申请一片连续的存储空间，并设置两个指针进行管理。一个是队头指针front，它指向队头元素；另一个是队尾指针rear，它指向下一个入队元素的存...
C++ 队列与循环队列 详解
m0_66420734的博客
06-01 331
C++ 队列与循环队列
二叉树的各种创建方法
热门推荐
lingling_nice的博客
07-08 7万+
1.前序创建#include&lt;stdio.h&gt; #include&lt;string.h&gt; #include&lt;stdlib.h&gt; #include&lt;malloc.h&gt; #include&lt;iostream&gt; #include&lt;stack&gt; #include&lt;queue&gt; using namespace std; typed
二叉树的创建（数据结构） C语言版
m0_67400973的博客
06-21 2万+
目录一.二叉树的存储结构二.二叉树的创建三.二叉树的遍历1.先序遍历2.中序遍历3.后序遍历4.层序遍历二叉树的基本存储结构如下所示leftchild:存储左孩子节点的地址rightchild:存储右孩子节点的地址data：当前节点存储的信息 二.二叉树的创建 创建一棵二叉树的关键在于如何将一个一个的节点按照树的脉络连接起来，在这里我们选择用一棵最小的满二叉树来说明我们需要首先创建根节点，并且向里面保存数据，然后接着在向左孩子里面输入数据，最后是右孩子，其实这种从根节点开始，依次访问左节点，右节点的方式叫做
数据结构——二叉链表创建二叉树（C语言版）
正弦定理的博客
12-08 6万+
数据结构——二叉链表创建二叉树一、思想（先序思想创建）：二、创建二叉树（1）传一级参数方法 一、思想（先序思想创建）： 第一步先创建根节点,然后创建根节点左子树,开始递归创建左子树，直到递归创建到的节点下不继续创建左子树，也就是当下递归到的节点下的左子树指向NULL，结束本次左子树递归，返回这个节点的上一个节点，开始创建右子树，然后又开始以当下这个节点，继续递归创建左子树，左子树递归创建完，就递归创建右子树，直到递归结束返回到上一级指针节点（也就是根节点下），此时根节点左边子树创建完毕，开始创建右边子树，
二叉树的创建和基本操作（详解）
oorik的博客
09-27 2万+
本文主要讲解递归实现二叉树的代码，对于树，二叉树的性质概念不多赘述我们以'#'代表空结点(为已有结点下的左右空孩子)，方便创建二叉树，我们以下图的二叉树作为讲解。
平衡二叉树（AVL）图解与实现
小张的专栏
10-31 6万+
个人技术博客：http://blog.ztgreat.cn 平衡二叉树（Balanced BinaryTree）又被称为AVL树。它具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。   平衡二叉树一般是一个有序树，它具有二叉树的所有性质，其遍历操作和二叉树的遍历操作相同。但是由于其对二叉树施加了额外限制，因而其添加、删除操作都必须...
二叉树建立及遍历操作算法分析与设计及复杂度分析
05-11
二叉树是一种非常重要的数据结构，其建立和遍历操作算法的设计和复杂度分析也是非常重要的。下面是二叉树建立和遍历操作算法的分析与设计。 1. 二叉树的建立算法 二叉树的建立有两种方式：递归法和非递归法。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值