二叉树及其遍历（递归和非递归实现）

最新推荐文章于 2021-09-24 20:40:48 发布
最新推荐文章于 2021-09-24 20:40:48 发布
阅读量859 收藏 4
点赞数
分类专栏： 数据结构和基本算法 文章标签： 二叉树 遍历
本文为博主原创文章，转载请务必附上文章网址，谢谢。
本文链接：https://blog.csdn.net/zjw_python/article/details/72808518
版权

1.基本概念

二叉树：一种特殊的树形结构，它的特点是每个结点至多只有两棵子树（即二叉树中不存在度大于2的结点），并且，二叉树的子树有左右之分，其次序不能任意颠倒。

二叉树的五种形态：空二叉树、只有一个根结点、根节点只有左子树、根节点只有右子树、根节点既有左子树又有右子树。

特殊二叉树：

  • 斜树（所有结点只有左子树的二叉树叫左斜树，所有结点只有右子树的二叉树叫右斜树，与线性表结构类似）
  • 满二叉树（所有分支结点都存在左子树和右子树，且所有叶子结点都在同一层，即拥有最大结点数）
  • 完全二叉树（从上到下，从左到右依次填满树结构，若一层没填满，则不能跳到一层。满二叉树为特殊的完全二叉树）

二叉树的性质：

  • 性质1 在二叉树的第i层上至多有 2i−1 个结点
  • 性质2 深度为k的二叉树至多有 2k−1 个结点
  • 性质3 对于任何一棵二叉树，如果其叶子结点数为n0，度为2的结点数为n2，则n0=n2+1
  • 性质4 具有n个结点的二叉树，其深度为 ⌊log2n⌋+1 （ ⌊x⌋ 不大于x的最大整数）
  • 性质5 如果对于一棵有n个结点的完全二叉树的结点按层序编号（从第1层到 ⌊log2n⌋+1 层，每层从左至右），对任 意一结点 i（ 1≤i≤n ）有：
    1. 如果i=1，则i是根节点，无双亲。如果i>1，则 ⌊i/2⌋ 是其双亲结点
    2. 如果2i>n，则i结点的无左孩子，否则i结点左孩子为2i
    3. 如果2i+1>n，则i结点无右孩子，否则i结点右孩子为2i+1

2.二叉树的存储结构

顺序存储结构

按照完全二叉树的结构，从1开始依次对各结点编号，并根据编号将其存入对应下标的数组中。不存在的结点用“0”或其他符号表示。此类方法对于非完全二叉树，可能会造成大量存储空间的浪费。

链式存储结构（二叉链表）

该存储方法在每个结点中设置两个指针域，分别指向该结点的左孩子和右孩子。

 //二叉树的链式存储结构定义  
typedef char TElemType;         //元素的数据类型根据实际情况而定，这里假设为char

typedef struct TNode          //结点结构 
{  
    TElemType      data;           //数据域，用于存储结点数据   
    struct TNode  *lchild;     //指针，指向该结点的左孩子 
    struct TNode  *rchild;     //指针，指向该结点的右孩子             
}BiTNode,*BiTree;

如有需要，还可以增加一个指针域指向双亲，形成三叉链表。

3.二叉树的遍历

二叉树的遍历是从根节点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。
二叉树的遍历方式有很多，如果限制从左到右的方向，则主要包括前序遍历、中序遍历、后序遍历和层序遍历
每次遍历时，对各结点的操作，此处定义为最简单的输出操作：

void printelement(TElemType e)  //定义visit函数，最简单的就是print直接输出 
{
    printf("%c",e);
}

前序、中序和后序遍历有递归和非递归两种实现方法。非递归遍历方法需要运用栈这种数据结构，在此定义栈的数据结构以及建栈、压栈、出栈和验证栈是否为空操作：

typedef BiTNode* ElemType;    //定义数据类型为指向树结点的指针
typedef struct Node
{
    ElemType data;
    struct Node*next;
}Node,*LinkStack;

int InitStack(LinkStack*S)
{
    (*S)=(Node*)malloc(sizeof(Node));      //头结点 
    if (!(*S)) return ERROR;
    (*S)->next=NULL;                        
    (*S)->data=0;                         //头结点数据域用来存储栈长度 
}

int StackEmpty(LinkStack S)   //验证栈是否为空 
{
    if (S->data==0) return TRUE;
    return FALSE; 
}

int Push(LinkStack *S,ElemType e)   //将元素e压栈 
{
    Node*p;
    p=(Node*)malloc(sizeof(Node));
    if (!p) return ERROR;
    p->data=e;
    p->next=(*S)->next;
    (*S)->next=p;
    (*S)->data++;
    return OK;
}

int POP(LinkStack *S,ElemType*e)  //将栈顶元素出栈，并将值返回给e 
{
    Node*p;
    if (StackEmpty(*S)) return ERROR;
    p=(*S)->next;
    *e=p->data;
    (*S)->next=p->next;
    free(p);
    (*S)->data--;
    return OK;
}

前序遍历

若二叉树不为空，先访问根结点，然后前序遍历左子树，再前序遍历右子树。

void PreOrderTraverse(BiTree T,void(*visit)(TElemType))  //递归
{
    if (T==NULL) return;
    visit(T->data);
    PreOrderTraverse(T->lchild,visit);
    PreOrderTraverse(T->rchild,visit);
} 
void PreOrderTraverse(BiTree T,void(*visit)(TElemType))  //非递归
{
    BiTNode*p;
    LinkStack S;
    InitStack(&S);
    p=T;
    while (p||!StackEmpty(S))     //当树非空或栈不为空时进行遍历操作 
    {
        if (p)                     //当前结点存在时
        {
            Push(&S,p);            //将结点压栈
            visit(p->data);       //访问当前结点
            p=p->lchild;           //指向当前结点的左孩子
        }else
        {
            POP(&S,&p);            //当前结点不存在时，则弹出栈顶结点，使其成为当前结点 
            p=p->rchild;           //指向当前结点的右孩子 
        }
    }
}

中序遍历

若二叉树不为空，先中序遍历左子树，然后访问根结点，再中序遍历右子树。

void InOrderTraverse(BiTree T,void(*visit)(TElemType))  //递归
{
    if (T==NULL) return;
    InOrderTraverse(T->lchild,visit);
    visit(T->data);
    InOrderTraverse(T->rchild,visit);
}
void InOrderTraverse(BiTree T,void(*visit)(TElemType))  //非递归
{
    BiTNode*p;
    LinkStack S;
    InitStack(&S);
    p=T;
    while (p||!StackEmpty(S))      //当树非空或栈不为空时进行遍历操作 
    {
        if (p)                  //当前结点存在时 
        { 
            Push(&S,p);         //将结点压栈 
            p=p->lchild;        //指向当前结点的左孩子 
        }else
        {
            POP(&S,&p);        //当前结点不存在时，则弹出栈顶结点，使其成为当前结点 
            visit(p->data);    //访问当前结点 
            p=p->rchild;       //指向当前结点的右孩子 
        }
    }
}

后序遍历

若二叉树不为空，先后序遍历左子树，然后后序遍历右子树，再访问根结点。

void PostOrderTraverse(BiTree T,void(*visit)(TElemType))  //递归
{
    if (T==NULL) return;
    PostOrderTraverse(T->lchild,visit);
    PostOrderTraverse(T->rchild,visit);
    visit(T->data);
}
void PostOrderTraverse(BiTree T,void(*visit)(TElemType)) //非递归
{
    BiTNode*pcur,*plastvisit;    //pcur为当前结点，plastvisit为上一个访问的结点 
    LinkStack S;
    InitStack(&S);               //建栈 
    pcur=T;                     //使根结点成为当前结点 
    plastvisit=NULL;             
    while(pcur)                 //寻找后序遍历的第一个结点，并将沿路结点依次压栈 
    {
        Push(&S,pcur);
        pcur=pcur->lchild;
    }
    while (!StackEmpty(S))    //栈为空时，所有结点输出完毕，退出循坏 
    {
        POP(&S,&pcur);        //将栈顶结点弹出，成为当前结点 
        if (pcur->rchild==NULL || pcur->rchild==plastvisit) //如果当前结点的右孩子不存在或右孩子已经被访问过，则可以输出该结点 
        {
            visit(pcur->data);
            plastvisit=pcur;   //使当前结点成为上一个访问的结点，为下一轮做准备 
        }else                //否则说明当前结点的右子树还没有遍历，不能输出当前结点 
        {
            Push(&S,pcur);  //将当前结点重新压栈 
            pcur=pcur->rchild;  //进入当前结点的右子树 
            while(pcur)    
            {
                Push(&S,pcur);
                pcur=pcur->lchild;
            }
        }    
    }
}

层序遍历

若二叉树不为空，从树的第一层开始，从左至右，从上至下逐层访问各结点。
和前三种遍历方法相比，层序遍历较为不同，在此借助队列结构来实现遍历。
首先定义队列的数据结构以及建队、入队、出队和验证队列是否为空的操作：

typedef BiTNode* ElemType; //定义数据类型为指向树结点的指针

typedef struct Node   
{  
    ElemType data;            //数据域，用于存储结点数据   
    struct Node *next;        //指针域，存储下一个结点的地址信息                
}QNode,*Queueptr;  

typedef struct  
{  
    Queueptr front,rear;     //定义头指针和尾指针   
}LinkQueue;

int InitQueue(LinkQueue*Q)    //建立队列   
{  
    Q->front=(QNode*)malloc(sizeof(QNode));   //建立头结点   
    if (!Q->front) return ERROR;  
    Q->front->next=NULL;     
    Q->rear=Q->front;           //头尾指针同时指向头结点，队列为空   
    return OK;  
}

int QueueEmpty(LinkQueue*Q)  //验证队列是否为空   
{  
    if (Q->front==Q->rear) return TRUE;  
    return FALSE;   
}

int EnQueue(LinkQueue*Q,ElemType e)  //插入元素e队列   
{  
    QNode*p;  
    if (!Q->front) return ERROR;  
    p=(QNode*)malloc(sizeof(QNode));  
    p->data=e;  
    p->next=NULL;                  //使新节点next指针指向空   
    Q->rear->next=p;               //使前一结点指向新节点   
    Q->rear=p;                     //使尾指针指向新节点   
}  

int DeQueue(LinkQueue*Q,ElemType*e)  //删除队头元素，返回值给e   
{  
    QNode*p;  
    if (!Q->front) return ERROR;  
    p=Q->front->next;                //记录队头结点   
    *e=p->data;  
    Q->front->next=p->next;          //将头结点指向队头结点的下一个结点   
    if (Q->rear==p) Q->rear=Q->front;  //若队头结点为最后一个结点，则使尾指针指向头结点   
    free(p);                          //释放队头结点   
    return OK;  
}

层序遍历：

void LevelOrderTraverse(BiTree T,void(*visit)(TElemType))
{
    BiTNode*p;
    LinkQueue Q;        //定义队列类型 
    InitQueue(&Q);     //创建队列  
    if (T!=NULL) EnQueue(&Q,T);   //如果树非空，把根结点入队列 
    while(!QueueEmpty(&Q))     //如果队列非空，则继续遍历操作 
    {
        DeQueue(&Q,&p);      //将队列头的树结点弹出 
        visit(p->data);      //对出队列的结点进行访问 
        if (p->lchild)       //如果该出队列的结点左孩子存在，则将其左孩子入队列 
        EnQueue(&Q,p->lchild);
        if (p->rchild)      //如果该出队列的结点右孩子存在，则将其右孩子入队列 
        EnQueue(&Q,p->rchild);
    }

}

4.二叉树的建立

前面我们了解了几种基本的二叉树遍历方法，现在我们就可以运用这些方法来建立二叉树。只需把前面遍历过程中对每个结点的输出操作改为输入操作即可。例如用前序遍历的方法建立二叉树：

//二叉树的建立
void CreateBiTree(BiTree * T)
{
    char ch;
    scanf("%c",&ch);
    if (ch=='#') *T=NULL;    //如果结点数据为空，则将指针指向空 
    else
    {
        *T=(BiTree)malloc(sizeof(BiTNode));  //申请结点空间 
        if (!*T) exit(OVERFLOW);
        (*T)->data=ch;                       //输入数据，生成根节点 
        CreateBiTree(&((*T)->lchild));      //构造左子树 
        CreateBiTree(&((*T)->rchild));      //构造右子树 
    }
}

5.代码验证

int main()
{
    BiTree T;
    printf("按先序遍历建立二叉树:\n");
    CreateBiTree(&T);
    printf("先序遍历:\n");
    PreOrderTraverse(T,printelement);
    printf("\n中序遍历:\n");
    InOrderTraverse(T,printelement);
    printf("\n后序遍历:\n");
    PostOrderTraverse(T,printelement);
    printf("\n层序遍历:\n");
    LevelOrderTraverse(T,printelement);
    return 0;
}

这里写图片描述

PAT-python-zjw
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树遍历 非递归 C++实现代码
09-05
二叉树遍历是计算机科学中处理树形数据结构的基本操作，主要分为前序遍历、中序遍历和后序遍历。这三种遍历方法各有特点，递归实现时利用了树的自然递归定义，代码简洁易懂。然而，非递归实现则需要借助辅助数据结构...
二叉树的遍历——递归以及非递归实现
06-03
vs2010下运行编写，使用了STL栈，实现了基本的插入、删除、计算深度、查找，主要是遍历，包括递归遍历，以及非递归的前序中序后序遍历，每个函数都有测试用例，如果存在错误，请在给我留言。
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出结点的遍历序列；（3）求二叉树的深度、结点数目、叶结点数目；（选做）（4）将二叉树每个结点的左右子树交换位置。（选做）【基本要求】从键盘接受输入（先序），以二叉链表作为存储结构，建立二叉树（以先序来建立）【测试数据】如输入：ABC##DE#G##F###（其中#表示空格字符）则输出结果为 先序：ABCDEGF中序：CBEGDFA后序：CGEFDBA层序：ABCDEFG【选做内容】采用非递归算法实现二叉树遍历。
二叉树的非递归遍历
weixin_30518397的博客
08-25 358
二叉树的非递归遍历 二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用...
有关二叉树的相关实现：建树，遍历(递归与非递归实现)
千里之行，始于足下
07-19 2263
首先定义二叉树的节点 struct BTNode { int data; BTNode *left; BTNode *right; }; 然后先序建立二叉树 思路：以数组中的元素先序构建二叉树，过程就是不断插入，直至数组中没有元素 //先序建立二叉树 void insert_node(BTNode **root, int *data, int i) { if(i<=data[0]
二叉树遍历的递归与非递归实现
zhishuang.rao的博客
04-14 323
二叉树的递归实现代码很简单，非递归实现主要运用栈来实现： 1.先将结点信息保存 2.之后再退回一步 3.重复一二步#include <iostream> #include <stdlib.h> using namespace std; #define MAXSIZE 100 typedef struct BiNode { char data; BiNode *lchild,*
二叉树的遍历方式-递归及非递归实现
qq_45605759的博客
12-04 112
二叉树的节点表示 首先，要完成二叉树的方式，要先定义二叉树的节点，节点定义如下： class Node { char value; Node left; Node right; public Node(char value) { this.value = value; } } 二叉树的前序遍历 二叉树的前序遍历：先遍历根节点，再遍历左子树...
二叉树先序遍历的非递归算法具体实现
09-04
通常，我们使用递归方法来实现先序遍历，但有时候，非递归方法可能更有利于理解和优化。本文将详细讨论如何用非递归算法实现二叉树的先序遍历。 非递归算法通常使用栈来辅助遍历过程。基本思路是首先将根节点压入栈...
二叉树递归与非递归遍历
11-03
这三种遍历方式都分为递归和非递归两种实现方式。 **递归遍历** 1. **前序遍历**： - 访问根节点。 - 递归遍历左子树。 - 递归遍历右子树。 2. **中序遍历**： - 递归遍历左子树。 - 访问根节点。 - 递归...
二叉树遍历递归与非递归实现
12-26
基于C语言编写的递归与非递归方法的二叉树先中后序遍历
二叉树——二叉树的遍历
02-21 801
二叉树遍历（Binary Tree Traversal）  二叉树的遍历是指按照一定次序访问树中所有结点，并且每个结点仅被访问一次的过程。它是最基本的运算，是二叉树中所有其他运算的基础。   重用的4种遍历方法如下： 1.前序遍历   前序遍历的二叉树的过程如下：   (1)访问根结点   (2)前序遍历左子树   (3)前序遍历右子树  前序遍历二叉树的递归算法如下：//前序遍历（递归
遍历二叉树
杨森源的博客
05-31 3923
1.  二叉树的遍历         遍历定义  ——顺着某一条搜索路径巡访二叉树中的结点，使得 每个结点均被访问一次，而且仅被访问一次。         “访问”的含义可以很广，如：输出结点的信息等。          遍历用途——查找具有某种特征的结点；对树中全部结点逐一进行某种处理。遍历是二叉树一切运算的基础和核心。 遍历规则 二叉树由根、左子树、右子树构成，定义为D、 L
二叉树---遍历
爱CV
12-01 554
一般用递归和堆栈来遍历 前序遍历：打印 - 左 - 右 中序遍历：左 - 打印 - 右 后序遍历：左 - 右 - 打印 1. 递归遍历 递归函数实现， 定义 inorder(root) 表示当前遍历到 root 节点的答案，那么按照定义，我们只要递归调用 inorder(root.left) 来遍历 \textit{root}root 节点的左子树，然后将 root 节点的值加入答案，再递归调用inorder(root.right) 来遍历root 节点的右子树即可，递归终止的条件为碰到空节点。
二叉树的遍历
u010400772的博客
10-25 822
首先来看一棵二叉树： 1、前序遍历： 前序遍历首先访问根结点然后遍历左子树，最后遍历右子树。在遍历左、右子树时，仍然先访问根结点，然后遍历左子树，最后遍历右子树。 若二叉树为空则结束返回，否则： （1）访问根结点； （2）前序遍历左子树； （3）前序遍历右子树 ； 需要注意的是：遍历左右子树时仍然采用前序遍历
二叉树非递归遍历——python
qq_44965314的博客
09-24 254
参考博客☞python实现二叉树和它的七种遍历 前序遍历 def pre_order(root): if not root: return None stack = [] node = root while node or stack: while node: print(node.val) stack.append(node) node = node.left node = stack.pop() node = node.right 中序遍历 def mid_o
Python实现二叉树的递归和非递归遍历
柳汀轩
09-26 3056
本文定义的二叉树结构如下：class BinNode(): def __init__( self, val ): self.lchild = None self.rchild = None self.val = val先序遍历 递归写法def preOrder(self, root): if root == None:
二叉树遍历：递归与非递归实现
"二叉树遍历的递归与非递归实现，包括前序、中序和后序遍历，以及二叉树的基本操作如交换左右子树。" 二叉树是一种数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。这种数据结构在计算机科学...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值