二叉树的相关操作（各种遍历，叶子节点数，深度，完全二叉树，相等树，创建）

最新推荐文章于 2024-08-28 23:47:14 发布
最新推荐文章于 2024-08-28 23:47:14 发布
阅读量100 收藏
点赞数
分类专栏： 笔记 文章标签： 数据结构 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56291021/article/details/121733232
版权
这段代码实现了二叉树的各种操作，包括使用栈和队列进行前序、中序、后序遍历，非递归遍历，计算叶子节点数量，计算树的深度，判断是否为完全二叉树，交换左右子树等功能。同时，还提供了输入数据构建二叉树，层次遍历和比较两棵树是否相等的实现。
摘要由CSDN通过智能技术生成

栈的相关操作

typedef struct stack  {
    bitree *data;
    int front, top;
}sta;
void init_stack(sta *q) {
   q->data = new bitree [100];
   q->front =q->top = 0;
}
void push(sta* q, bitree c) {
    q->data[q->top]= c;
    q->top++;
}
void pop(sta* q) {
    q->top--;
} 
bool empty(sta *q) {
    if (q->front == q->top)
        return 1;
    else
        return 0;
}
bitree gettop(sta *q) {
    return q->data[q->top-1];
}

队列的相关操作

typedef struct queue {
     bitree * data;
     int front, rear;
 }que, *sque;
 void init_que(sque s) {
     s->data = new bitree[100];
     s->front = s->rear = 0;
 }
 void que_push(sque s,bitree q) {
     s->data[s->rear++]=q;
 }
 void que_pop(sque s) {
     s->front++;
 }
 bitree que_gettop(sque s) {
     return s->data[s->front];
 }
 bool que_empty(sque s) {
     if (s->front == s->rear)
         return 1;
     else
         return 0;
 }

二叉树的建立

typedef struct BiTREE* bitree;
void init(bitree* p) {
    int a;
    cin >> a;
    if (a == -1) {
        *p = NULL;
    }
    else {
        (*p) = new struct BiTREE[1];
        (*p)->data = a;
        (*p)->lc = NULL;
        (*p)->rc = NULL;
        init(&(*p)->lc);
        init(&(*p)->rc);
        flag = 1;
    }
}

递归遍历

void preview(bitree s) {//前序
    if (s) {
        cout << s->data<<" ";
        preview(s->lc);
        preview(s->rc);
    }
}
void inview(bitree s) {//中序
    if (s) {
        inview(s->lc);
        cout << s->data<<" ";
        inview(s->rc);
    }
}
 void postview(bitree s) {后序
     if (s) 
         {
             postview(s->lc);
             postview(s->rc);
             cout << s->data << " ";
         }
}

非递归

 void INpreview(bitree s) {//非递归前序
     sta a;
     init_stack(&a);
     bitree q;
     q = s;
     while (!empty(&a)||q) {
         if (q) {
             push(&a, q);
             cout << q->data<<" ";
             q = q->lc;
         }
         else {
             q=gettop(&a);
             q = q->rc;
             pop(&a);
         }
     }
 }
 void INinview(bitree s) {//非递归中序
     sta a;
     init_stack(&a);
     bitree q;
     q = s;
     while (!empty(&a) || q) {
         if (q) {
             push(&a, q);
             q = q->lc;
         }
         else {
            q= gettop(&a);
             cout << q->data << " ";
             q = q->rc;
             pop(&a);
         }
     }
 }
 void INpostview(bitree s) {//非递归后序
     sta a;
     init_stack(&a);
     bitree q;
     bitree pre=NULL,top;
     q = s;
     while (!empty(&a)||q) {
         while(q) {
             push(&a, q);
             q = q->lc;
         }
         top= gettop(&a);
          if (!top->rc||top->rc==pre) {
              cout <<top->data << " ";
              pop(&a);
              pre = top;
         }
         else {
             q = top->rc;
         }
     }
 }

叶子节点数

int leafnode(bitree s) {
     if (!s)
         return 0;
     else if (!s->lc && !s->rc)
         return 1;
     else
         return leafnode(s->lc) + leafnode(s->rc);  
 }

深度

int depthtree(bitree s) {
     if (!s)
        return 0;
       else if(!s->lc&&!s->rc)
       return 1;
       else{
       deplc = depthtree(s->lc);
       deprc = depthtree(s->rc);
       }
     if (deplc > deprc)
         return deplc + 1;
     else
         return deprc + 1;
 }

相等

 bool sametree(bitree s, bitree d) {
       if (!s && !d)
         return 1;
        else if(!s||!d)
            return 0;
        else if (s->data == d->data) 
            return sametree(s->lc, d->lc) && sametree(s->rc, d->rc);
         else {
             return 0;
     }
  }

判断是否为完全二叉树

bool judge(bitree s) {//与层次遍历的代码基本相似
     if (s) {
         que a;
         bitree q;
         q = s;
         init_que(&a);
         que_push(&a, q);
         while (!que_empty(&a)) {
             q = que_gettop(&a);
             que_pop(&a);
             if (!q)
                 break;
             que_push(&a, q->lc);
             que_push(&a, q->rc);
         }
         while (!que_empty(&a)) {
             q = que_gettop(&a);
             if (q)
                 return 0;
             que_pop(&a);
         }
         return 1;
     }
 }

交换左右子树

void swap(bitree s) {
     if (s) {
         bitree temp;
         temp= s->lc;
         s->lc= s->rc;
         s->rc = temp;
         swap(s->lc);
         swap(s->rc);
     }
 }

完整代码

#include <iostream>
#include <cstdio>
using namespace std;
typedef struct BiTREE* bitree;
int flag = 0;
int deplc, deprc;
//栈的相关操作
typedef struct stack  {
    bitree *data;//存放结点的地址便于回退
    int front, top;
}sta;
void init_stack(sta *q) {//初始化栈
   q->data = new bitree [100];
   q->front =q->top = 0;
}
void push(sta* q, bitree c) {将结点地址压入站
    q->data[q->top]= c;
    q->top++;
}
void pop(sta* q) {
    q->top--;//出栈操作
} 
bool empty(sta *q) {//判断是否为空
    if (q->front == q->top)
        return 1;
    else
        return 0;
}
bitree gettop(sta *q) {//取栈顶元素
    return q->data[q->top-1];
}
//以上区间的函数是栈的相关操作
 typedef struct BiTREE
{
    int data;
    bitree lc, rc;
}bit;
//队列的相关操作
 typedef struct queue {
    bitree * data;//存放结点的地址便于回退
     int front, rear;
 }que, *sque;
 void init_que(sque s) {//初始化队列
     s->data = new bitree[100];
     s->front = s->rear = 0;
 }
 void que_push(sque s,bitree q) {
     s->data[s->rear++]=q;
 }//将结点地址压入队列
 void que_pop(sque s) {
     s->front++;
 }//压出数据
 bitree que_gettop(sque s) {
     return s->data[s->front];
 }//取栈顶元素
 bool que_empty(sque s) {//判断是否为空
     if (s->front == s->rear)
         return 1;
     else
         return 0;
 }
 //以上区间的函数是队列的相关操作
 void level_view(bitree s) {
     if (s) {
         que a;
         init_que(&a);
         bitree q,top;
         q = s;
         que_push(&a, q);
         while (!que_empty(&a)) {
             q = que_gettop(&a);
             cout << q->data<<" ";
             que_pop(&a);
             if (q->lc)
                 que_push(&a, q->lc);
             if (q->rc)
                 que_push(&a, q->rc);
         }
     }
 }
void init(bitree* p) {//二级指针，在函数中为一个指针分配内存空间能用引用和二级指针或返回根结点的地址
    int a;
    cin >> a;
    if (a == -1) {
        *p = NULL;
    }
    else {
        (*p) = new struct BiTREE[1];
        (*p)->data = a;
        (*p)->lc = NULL;
        (*p)->rc = NULL;
        init(&(*p)->lc);
        init(&(*p)->rc);
        flag = 1;
    }
}

void preview(bitree s) {
    if (s) {
        cout << s->data<<" ";
        preview(s->lc);
        preview(s->rc);
    }
}
void inview(bitree s) {
    if (s) {
        inview(s->lc);
        cout << s->data<<" ";
        inview(s->rc);
    }
}
 void postview(bitree s) {
     if (s) 
         {
             postview(s->lc);
             postview(s->rc);
             cout << s->data << " ";
         }
}
 void INpreview(bitree s) {
     sta a;
     init_stack(&a);
     bitree q;
     q = s;
     while (!empty(&a)||q) {
         if (q) {
             push(&a, q);
             cout << q->data<<" ";
             q = q->lc;
         }
         else {
             q=gettop(&a);
             q = q->rc;
             pop(&a);
         }
     }
 }
 void INinview(bitree s) {
     sta a;
     init_stack(&a);
     bitree q;
     q = s;
     while (!empty(&a) || q) {
         if (q) {
             push(&a, q);
             q = q->lc;
         }
         else {
            q= gettop(&a);
             cout << q->data << " ";
             q = q->rc;
             pop(&a);
         }
     }
 }
 void INpostview(bitree s) {
     sta a;
     init_stack(&a);
     bitree q;
     bitree pre=NULL,top;
     q = s;
     while (!empty(&a)||q) {
         while(q) {
             push(&a, q);
             q = q->lc;
         }
         top= gettop(&a);
          if (!top->rc||top->rc==pre) {
              cout <<top->data << " ";
              pop(&a);
              pre = top;
         }
         else {
             q = top->rc;
         }
     }
 }
 int leafnode(bitree s) {
     if (!s)
         return 0;
     else if (!s->lc && !s->rc)
         return 1;
     else
         return leafnode(s->lc) + leafnode(s->rc);  
 }
 int depthtree(bitree s) {
     if (!s)
        return 0;
       deplc = depthtree(s->lc);
       deprc = depthtree(s->rc);
     if (deplc > deprc)
         return deplc + 1;
     else
         return deprc + 1;
 }
 bool sametree(bitree s, bitree d) {
       if (!s && !d)
         return 1;
        else if(!s||!d)
            return 0;
        else if (s->data == d->data) 
            return sametree(s->lc, d->lc) && sametree(s->rc, d->rc);
         else {
             return 0;
     }
  }
 bool judge(bitree s) {
     if (s) {
         que a;
         bitree q;
         q = s;
         init_que(&a);
         que_push(&a, q);
         while (!que_empty(&a)) {
             q = que_gettop(&a);
             que_pop(&a);
             if (!q)
                 break;
             que_push(&a, q->lc);
             que_push(&a, q->rc);
         }
         while (!que_empty(&a)) {
             q = que_gettop(&a);
             if (q)
                 return 0;
             que_pop(&a);
         }
         return 1;
     }
 }
 void swap(bitree s) {
     if (s) {
         bitree temp;
         temp= s->lc;
         s->lc= s->rc;
         s->rc = temp;
         swap(s->lc);
         swap(s->rc);
     }
 }
int main()
{
    int N;
    cout << "输入第一个二叉树数据" << endl;
    bitree b;
    init(&b);
    bitree d;
    init(&d);
    if (flag)
        cout << "成功创建"<<endl;
    else
        cout << "创建失败";
    cout << "前序遍历" << endl;
    preview(b);
    cout << endl;
    cout << "中序" << endl;
    inview(b);
    cout << endl;
    cout << "后序" << endl;
    postview(b);
    cout << endl<< "非递归前序遍历"<< endl;
    INpreview(b);
    cout << endl;
    cout << "非递归中序" << endl;
    INinview(b);
    cout << endl;
    cout << "非递归后序" << endl;
    INpostview(b);
    int c = 0;
   c= leafnode(b);
   cout << endl<<"叶子节点数" << endl;
   cout << c;
    int c = 0;
   c= depthtree(b);
   cout << endl << "该树的深度" << endl;
   cout << c;
   if (sametree(b, d)) {
       cout << "两个树相似" << endl;
   }
   else
       cout <<endl<< "两个树不相似" << endl;
   cout << endl << "变换前非递归前序遍历" << endl;
   INpreview(b);
   cout << endl;
   swap(b);
   cout << endl << "变换后非递归前序遍历" << endl;
   INpreview(b);
   cout << endl;
    cout << "层次遍历" << endl;
    level_view(b);
    if (judge(b)) {
        cout << "是完全二叉树" << endl;
    }
    else {
        cout << "不是完全二叉树" << endl;
    }
}
卖火柴 的小女孩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++笔试题之求完全二叉树叶子节点数
草上爬的博客
04-26 2万+
C++笔试题之求完全二叉树叶子节点数：一、树的定义树是一种数据结构，它是由n（n&gt;=1）个有限结点组成一个具有层次关系的集合。树具有的特点有：（1）每个结点有零个或多个子结点（2）没有父节点的结点称为根节点（3）每一个非根结点有且只有一个父节点（4）除了根结点外，每个子结点可以分为多个不相交的子树。树的基本术语有：若一个结点有子树，那么该结点称为子树根的“双亲”，子树的根称为该结点的“孩子”。有相同双亲的结点互为“兄弟”。一...
C++实现根据先序遍历的结果创建二叉树，完成各种遍历以及获取树的高度的操作。
CheryHacker的博客
01-03 1321
二叉树的创建以及遍历一般都采用递归的方式进行，当然也有非递归的方式，本文不做讨论。本文二叉树的创建是根据先序遍历的结果进行建树的，空节点用#补满，具体样例见文末的测试数据。下面附上代码： #include &lt;iostream&gt; #include &lt;queue&gt; #include &lt;string&gt; using namespace std; //定义节点的结构...
C语言数据结构学习笔记(10)-二叉树的创建及遍历
laven_li的博客
10-28 360
/*二叉树的创建及遍历 输出结果： 请输入待创建的二叉树:ABD##E##CF### 前序遍历:A B D E C F 中序遍历:D B E A F C 后序遍历:D E B F C A 层序遍历:A B C D E F 请按任意键继续. . . */ # include <stdio.h> # include <stdlib.h> # define ElemType char # define MAX_SIZE 20 # define bool int # define true
c#二叉树 取叶子节点个数_使用JS实现二叉树（3）——高级操作
weixin_39530509的博客
11-23 197
本篇使用JS继续实现二叉树的一些操作，名字里有高级，其实和《JavaScript高级程序设计》的名字里也有高级但是其实整本书都是很基础的知识一样，本篇的操作说到底也是很基础的操作。首先通过代码框架来看看本篇都会设计到哪些操作。代码框架class 获得二叉树中节点个数获取二叉树中的节点个数可以有递归和非递归两种方法，递归的方法思路比较简单，根节点加上左子树节点的个数，加上右子树节点的个数返回就行了。...
数据结构上机实验——二叉树的实现、二叉树遍历、求二叉树的深度/节点数目/叶节点数目、计算二叉树度为1或2的节点数、判断二叉树是否相似
Crocodile1006的博客
10-29 1922
数据结构、二叉树、创建一颗二叉树、对这棵二叉树进行遍历、求二叉树的深度/节点数目/叶节点数目、计算二叉树中度为 1 或 2 的结点数、判断2棵二叉树是否相似，若相似返回1，否则返回0
二叉树与N叉树的深度优先遍历（C++）
qq_41773103的博客
02-19 1200
目录前言一、二叉树的遍历1.1 前序遍历1.2 中序遍历1.3 后序遍历二、N叉树的遍历2.1 前序遍历2.2 后序遍历总结 前言 前序遍历：根节点->左子树->右子树（根->左->右） 中序遍历：左子树->根节点->右子树（左->根->右） 后序遍历：左子树->右子树->根节点（左->右->根） 提示：以下代码仅供参考 一、二叉树的遍历 1.1 前序遍历 题目描述：给定一个二叉树的根节点 root ，返回它的前序遍历。 /** .
LeetCode Java刷题笔记—222. 完全二叉树的节点个数
终生学习践行者
04-14 629
LeetCode Java刷题笔记—222. 完全二叉树的节点个数
二叉树的介绍，遍历，查找节点，删除节点及其代码实现（Java）
代码之美
10-22 972
1 树的介绍 树的常用术语(结合示意图理解):节点：A B C D E F G H根节点：A父节点：见图子节点：见图叶子节点 (没有子节点的节点)：H E F G节点的权：即为节点的值路径(从root节点找到该节点的路线)：层：见图子树：见图树的高度(最大层数)：本图为5层森林 :多颗子树构成森林。 1.1 二叉树的概念 二叉树定义：树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。 二叉树的子节点分为左节点和右节点。 满二叉树定义：如果该二叉树的所有叶子节点都在最后一层，并且结
数据结构：二叉树详解（二叉树性质、遍历、创建、判断两棵树是否相等）
m0_46332283的博客
10-22 880
二叉树是一种树形结构，其特点是每个节点至多只有 2 棵子树，并且子树又左右之分，次序不能颠倒，即二叉树是有序树。
二叉树总结创建，遍历
热门推荐
heyuchang666的专栏
10-23 1万+
二叉树作为树的一种，是一种重要的数据结构，二叉树中的面试题比较常见的题型大概有下面几个：创建一颗二叉树（先序，中序，后序）、遍历一颗二叉树（先序，中序，后序和层次遍历）、求二叉树中叶子节点的个数、求二叉树的高度、求二叉树中两个节点的最近公共祖先、打印和为某一值的全部路径、求某一节点是否在一个树中等等。
LeetCode 1379. 找出克隆二叉树中的相同节点（二叉树遍历）
12-21
找出克隆二叉树中的相同节点" 是一个关于二叉树遍历的问题。在这个问题中，我们被给予两棵二叉树，一棵是原始树 `original`，另一棵是其副本，即克隆树 `cloned`，还有一个目标节点 `target`，它存在于原始树中。...
二叉树的存储与遍历
10247D的博客
09-24 626
学习目标 熟练掌握二叉树的存储方式 理解二叉树的三种遍历方式的实现过程 给出一棵二叉树，能够写出对应的三种遍历序列，给出任意两种遍历序列，能够推导并还原出二叉树并写出另外一种遍历序列 掌握三种遍历方式的代码实现，掌握给出两种遍历方式的序列，求第三种遍历序列的代码实现
数据结构
2301_80184169的博客
08-28 402
4.执行代码,复现段错误,产生包含出错信息的core文件(检查core文件是否生成)3.ulimit -c unlimited 不限制core文件的生成的大小。使用这种方法能够很好的解决段错误，在纠正和优化代码时效率显著提升。1.首先按照如下的方法配置Ubuntu，允许生成core文件。5.gdb a.out core 查看段错误产生的位置。2.重新编译代码并加入-g选项(允许进行GDB调试)
25版王道数据结构课后习题详细分析 第五章 树与二叉树 5.4 树、森林
2406_86301373的博客
08-26 451
解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：
Python-MNE-源定位和逆问题01：源估计（SourceEstimate）数据结构
weixin_58312922的博客
08-25 638
stc是MNE-Python的一个类，表示从源估计中获得的转换的时间序列。对于两个半球，数据分别存储在和中，储存形式为的形式为一个m*n的矩阵，m是这个半球的空间位置的数量，n是时间点的个数。和对应和。这些是表面表征的位置索引。表面的坐标存储在和中，分别表示左半球和右半球。
【数据结构】队列(Queue)
xiaochuan_bsj的博客
08-28 470
数组，双链表实现队列，附完整代码
基于R语言的统计分析基础：数据结构
m0_73500130的博客
08-25 917
R语言是一种用于统计分析和图形表示的编程语言和软件环境，它提供了多种数据结构以存储和操作数据。这些数据结构包括向量、矩阵、数组、数据框、列表、因子、Tibble、环境、公式、调用以及表达式。
数据结构（邓俊辉）学习笔记】串 10——BM_BC算法：坏字符
最新发布
weixin_44399845的博客
08-28 560
BM_BC算法：坏字符
Linux 数据结构 链表
mxyzhy的博客
08-28 142
单向链表操作
c二叉树的创建及遍历用先序和中序序列创建二叉树并进行后序遍历 有什么要注意的
05-22
创建二叉树时，先序序列的第一个元素为根节点，中序序列中根节点左边的元素构成左子树，根节点右边的元素构成右子树。递归地对左右子树进行相同的操作，直到叶子节点。 在进行后序遍历时，需要先遍历左子树，再遍历...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值