二叉树的部分操作

最新推荐文章于 2021-09-05 23:20:23 发布
原创 最新推荐文章于 2021-09-05 23:20:23 发布 · 447 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#二叉树 #遍历 #递归 #栈 #队列

本文介绍了一种二叉树的实现方法，并详细展示了二叉树的创建及多种遍历方式，包括前序、中序、后序、非递归中序（栈实现）、层序（队列实现）和中序线索化遍历。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

以下代码包括二叉树的创建、前中后序遍历（递归）、非递归中序遍历（栈实现）、层序遍历（队列实现）和中序线索化遍历。

  1. main
#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include"Tree.h"
#include"Queue.h"
#include"Stack.h"
#include"Tree.h"
#include"Marco.h"

using namespace std;
BiThrTree pre;//全局变量，表示刚刚访问过的结点


int main()
{
    BiThrTree  T = NULL;

    printf("二叉树测试程序开始：\n");

    printf("1.创建非空二叉树：\n");
    CreateBiThrTree(T);

    printf("\n2.前序遍历二叉树：\n");
    PreOrderTraverse(T);

    printf("\n3.中序遍历二叉树：\n");
    InOrderTraverse(T);

    printf("\n4.后序遍历二叉树：\n");
    PostOrderTraverse(T);

    printf("\n5.非递归中序遍历二叉树(用栈实现)：\n");
    NoRecursionInTraverse(T);

    printf("\n6.层序遍历二叉树（用队列实现）：\n");
    LevelOrderTraverse(T);


    printf("\n7.中序线索化遍历二叉树：\n");
    BiThrTree Thrt;
    InOrderThreading( Thrt,T );
    InOrderAfterThreading(Thrt);

    cout << "\n二叉树测试程序结束!" << endl;
    return OK;
}

2.Tree.c

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include"Tree.h"
#include"Stack.h"
#include"Queue.h"
#include"Marco.h"
using namespace std;

extern BiThrTree pre;


/********************对二叉树的操作********************/


//1.创建二叉树
int CreateBiThrTree(BiThrTree &T)
{
    char data;
    scanf("%c", &data);
    if (' ' == data)
    {
        T = NULL;                                       //如果字符为空，则根节点为空
    }
    else
    {
        if (!(T = (BiThrTree)malloc(sizeof(BiThrNode))))//否则建立根节点
        {
            printf("出错：创建结点时分配空间错误！");
            exit(OVERFLOW);
        }
        T->data = data; //根节点数据域
        T->LTag = Link;
        T->RTag = Link;
        CreateBiThrTree(T->lchild);                 //构造左子树
        CreateBiThrTree(T->rchild);                 //构造右子树
    }
    return OK;
}

//2.前序遍历
void PreOrderTraverse(BiThrTree T)
{
    if (T)
    {
        printf("%c", T->data);
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
}


//3.中序遍历
void InOrderTraverse(BiThrTree T)
{
    if (T)
    {
        InOrderTraverse(T->lchild);
        printf("%c", T->data);
        InOrderTraverse(T->rchild);
    }
}

//4.后序遍历
void PostOrderTraverse(BiThrTree T)
{
    if (T)
    {
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        printf("%c", T->data);
    }
}

//5.非递归中序遍历
void NoRecursionInTraverse(BiThrTree T)
{
    BiThrTree p;
    Stack s;

    if (!(s.base = (BiThrTree*)malloc(sizeof(BiThrNode))))  //初始化栈
    {
        printf("出错：栈初始化失败时分配存储空间失败！\n");
        exit(1);
    }
    s.top = s.base;
    s.stackSize = STACK_INIT_SIZE;


    p = T;
    while(p || (s.top - s.base))
    {
        while (p)                           //遍历左子树，直到最左下角的节点
        {
            Push(s, p);
            p = p->lchild;
        }

        if((s.top-s.base))                              //左子树为空，根结点退栈，再遍历右子树
        {
            Pop(s, p);
            printf("%c", p->data);
            p = p->rchild;
        }
    }
}


//6.层序遍历
void LevelOrderTraverse(BiThrTree T)
{
    Queue Q;
    BiThrTree p=T;                                     //p在过程中不断被赋予新的结点地址

    Q.front = Q.rear = (QPtr)malloc(sizeof(QNode));    //初始化链队列
    if (!Q.front)
    {
        cout << "\n初始化分配存储空间失败！\n" << endl;
        exit(1);
    }
    Q.front->next = NULL;

    if (p)
        EnQueue(Q, p);
    while (Q.front != Q.rear)
    {
        DelQueue(Q, p);                                 //将被删除的结点赋予p，从而实现结点的更新
        cout << p->data;
        if (p->lchild != NULL)
        {
            EnQueue(Q, p->lchild);
        }
        if (p->rchild != NULL)
        {
            EnQueue(Q, p->rchild);
        }
    }//while
}
//7.中序线索化遍历
int InOrderThreading(BiThrTree &Thrt,BiThrTree T)
{
    if (!(Thrt = (BiThrTree)malloc(sizeof(BiThrNode))))
    {
        printf("出错：分配空间错误！");
        exit(-2);
    }

    Thrt->LTag = Link;                          //建立头节点
    Thrt->RTag = Thread;
    Thrt->rchild = Thrt;                            //右指针回指指向头节点

    if (!T)                                     //二叉树空，头节点的lchild指向根节点
    {
        Thrt->lchild = Thrt;
    }
    else
    {
        Thrt->lchild = T;                       //T不为空，头节点的lchild连接根结点
        pre = Thrt;                             //全局变量pre初始化，始终指向刚刚访问过的结点
        InThreading(T);                         //中序遍历进行中序线索化，传入的是根结点
        pre->rchild = Thrt;
        pre->RTag = Thread;
        Thrt->rchild = pre;                     //最后一个结点进行线索化   
    }
    return OK;
}

void InThreading(BiThrTree p)
{
    if (p)
    {
        InThreading(p->lchild);                 //递归，左子树线索化,直至最左下角的结点，其左子树为空，不在继续递归

        //中间部分为对 当前结点 的线索化
        if (!p->lchild)                         //当前结点 没有左子树，前驱线索
        {
            p->LTag = Thread;
            p->lchild = pre;                        //p->lchild指向直接前驱
        }
        if (!pre->rchild)                       //刚访问过的结点 没有右子树，后继线索
        {
            pre->RTag = Thread;
            pre->rchild = p;                        //
        }
        pre = p;                                //保持pre指向刚刚访问过的结点
        InThreading(p->rchild);                 //递归，右子树线索化
    }
}

//利用已经线索化的二叉树进行中序遍历输出, 非递归
void InOrderAfterThreading(BiThrTree Thrt)          //传入的是pre，传入前进行的最后操作为：                                              
{                                               //pre->rchild = Thrt;pre->RTag = Thread;Thrt->rchild = pre;
    BiThrTree p;
    p = Thrt->lchild;

    while (p != Thrt)
    {
        while (p->LTag == Link)
        {
            p = p->lchild;
        }
        cout << p->data;
        while (p->RTag == Thread && p->rchild != Thrt)
        {
            p = p->rchild;
            cout << p->data;
        }
        p = p->rchild;
    }
}

3.Stack.c

#include<stdio.h>
#include<stdlib.h>
#include"Stack.h"
#include"Tree.h"
/***********************对栈的操作***********************/

//1.Push
void Push(Stack &s, BiThrTree e)
{
    // 栈满，追加空间
    if (s.top - s.base >= s.stackSize)
    {
        s.base = (BiThrTree *)realloc(s.base, (s.stackSize + STACKINCREMENT) * sizeof(BiThrNode));
        if (!s.base)
            exit(0);

        s.top = s.base + s.stackSize;
        s.stackSize = s.stackSize + STACKINCREMENT;
    }

    *(s.top) = e;      // 存放数据
    s.top++;
}

//2.Pop
void Pop(Stack &s, BiThrTree &e)
{
    if (s.top == s.base)
    {
        printf("\n出错：出栈时栈为空！\n");
        exit(-2);
    }

    e = *(--s.top);   // 将栈顶元素弹出并修改栈指针
}

4.Queue.c

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include"Queue.h"
#include"Marco.h"
#include"Tree.h"
using namespace std;
/*******************对队列的操作***************************/
//1.EnQueue
void EnQueue(Queue &Q, BiThrTree e)
{
    QPtr q;
    if (!(q = (QPtr)malloc(sizeof(QNode))))
    {
        printf("出错：队列分配存储空间失败！\n");
        exit(OVERFLOW);
    }

    q->data = e;
    q->next = NULL;
    Q.rear->next = q;
    Q.rear = q;
}

//2.DelQueue
void DelQueue(Queue &Q, BiThrTree &e)
{
    if (Q.front == Q.rear)
    {
        cout << "出错：执行删除操作的队列为空！" << endl;
        exit(1);
    }
    QPtr p = Q.front->next;
    e = p->data;
    Q.front->next = p->next;
    if (Q.rear == p)
    {
        Q.rear = Q.front;
    }
    free(p);
}

5.Tree.h

#ifndef TREE_H_
#define TREE_H_
#include<stdio.h>
#define STACK_INIT_SIZE 100
#define STACKINCREMENT  10

typedef enum PointerTag { Link, Thread };           //Link==0,表示指针，Thread==1，表示线索

typedef struct BiThrNode
{
    char data;
    struct BiThrNode *lchild;
    struct BiThrNode *rchild;
    PointerTag LTag;
    PointerTag RTag;
}BiThrNode, *BiThrTree;

/********************对二叉树的操作********************/
//1.创建
int CreateBiThrTree(BiThrTree &T);

//2.前序遍历
void PreOrderTraverse(BiThrTree T);

//3.中序遍历
void InOrderTraverse(BiThrTree T);

//4.后序遍历
void PostOrderTraverse(BiThrTree T);

//5.非递归中序遍历
void NoRecursionInTraverse(BiThrTree T);

//6.层序遍历
void LevelOrderTraverse(BiThrTree T);
//7.中序遍历并线索
int InOrderThreading(BiThrTree &Thrt,BiThrTree T);

void InThreading(BiThrTree p);

//利用已经线索化的二叉树进行中序遍历输出
void InOrderAfterThreading(BiThrTree Thrt);

#endif

6.Stack.h

#ifndef STACK_H_
#define STACK_H_
#include"Tree.h"
typedef struct
{
    BiThrTree *top;
    BiThrTree *base;
    int stackSize;
}Stack;                             //用于非递归遍历二叉树

/*******************需要的对栈的操作***********************/

//1.Push
void Push(Stack &s, BiThrTree e);

//2.Pop
void Pop(Stack &s, BiThrTree &e);

#endif

7.Queue.h

#ifndef QUEUE_H_
#define QUEUE_H_
#include"Tree.h"
typedef struct QNode                //用于层序遍历二叉树
{
    BiThrTree data;             //存储地址
    struct QNode *next;
}QNode, *QPtr;

typedef struct
{
    QPtr front;
    QPtr rear;
}Queue;

/******************对队列的操作****************************/
//1.EnQueue
void EnQueue(Queue &Q, BiThrTree e);

//2.DelQueue
void DelQueue(Queue &Q, BiThrTree &e);

#endif

8.Marco.h（此部分的代码作用暂时不大）

#ifndef MARCO_H_
#define MARCO_H_

#define OK 0
#define ERROR 1
//#define OVERFLOW -2

#endif

图片中结果的格式和上面的代码运行结果的格式不完全相同，但对结果并无影响
在编写二叉树的线索化的代码时，一直不清楚线索化的具体过程，尽管看上去很容易理解。希望在调试的过程中理解过程，但很难进行下去，因为并没有能够运行的代码，每当想到这里就果断放弃调试，感觉是对时间的浪费。终于，今天静下心来，搜到了一个二叉树动态线索化的网页，观看后勉强理解了，代码写出后，进行调试，进一步理解过程。当然，写代码时不断抄袭书中内容的习惯一直是硬伤，鉴于二叉树的重要性，打算完全靠自己重新写一次。望天道酬勤！

ps：在写这个程序期间，学习了部分C++的知识，但在上述代码中所夹杂的C++代码都是基本的输出，没有输入。（如有错误，望各位指出）。

二叉树的最大深度
fanglegefang的博客
04-21 414
一.题目描述 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的距离。 样例 给出一棵如下的二叉树: 1 / \ 2 3 / \ 4 5 这个二叉树的最大深度为3. 二.解题思路 利用递归分别遍历左子树和右子树,每递归一次节点到根节点的距离加1,最后比较哪个子树的最后一个节点离根节点的 三.实现代码 /**
L3数据结构-树及实现（day10、11）
楚子航
04-13 831
一、树的概念 树（Tree）是n（n≥0）个节点的有限集合T，它满足两个条件 ：有且仅有一个特定的称为根（Root）的节点； 其余的节点可以分为m（m≥0）个互不相交的有限集合T1、T2、……、Tm，其中每一个集合又是一棵树，并称为其根的子树 表示方法 ：树形表示法、目录表示法。 一个节点的子树的个数称为该节点的度数 一棵树的度数是指该树中节点的最大度数。 度数为零的节点称为树叶或终端节点 度数不为零的节点称为分支节点 除根节点外的分支节点称为内部节点。 一个节点系列k1,k2, ……,ki,k.
leetcode
weixin_43459759的博客
07-19 132
1、求二叉树最大深度 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明:叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7 返回它的最大深度3 。 int maxDepth(TreeNode* root) { if(root==NULL)return 0; int ldep,rdep; ...
二叉树的深度
Medlen
03-12 216
题目描述 输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。 可以通过递归的方式，这种方式实现简单，可以从底部向上计数也可以从顶部向下计数。 也可已通过非递归的方式实现。 1、自底部向上计数 public int TreeDepth(TreeNode root) { if(root==null) return 0...
[算法]死磕二叉树专题算法
weixin_33984032的博客
04-11 136
1. 二叉树前序中序后序遍历（递归和非递归） 构造二叉树： class Node{ public String value; public Node left; public Node right; public Node(String value) { this.value = value; } } 递归版前序遍...
LeetCode刷题 -- 树(一）
只不停的博客
02-21 266
104. 树的最大深度 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]， 3 / 9 20 / 15 7 返回它的最大深度 3 。 class Solution { public int maxDepth(TreeNode r...
java(二叉树的基本操作和部分二叉树相关的题)
12-26
很多二叉树操作，尤其是遍历操作，都可以通过递归方式简洁地实现。递归函数能够反复调用自身，直至达到基本情况，然后逐层返回处理结果。递归代码简洁，但需要注意避免栈溢出和重复计算的问题。 除了基本操作，...
数据结构平衡二叉树的操作演示
05-07
代码实现部分包括了查找、插入、删除、合并、分裂五种操作的实现代码。其中，查找操作使用递归的方式实现，插入和删除操作使用旋转调整实现，合并和分裂操作使用递归的方式实现。 四、结论 本篇文章对平衡二叉树的...
二叉树基本操作_二叉树基本操作_
10-02
二叉树的基本操作主要包括创建、查找、插入和删除节点，这些操作对于理解和掌握二叉树至关重要。接下来，我们将详细讨论这些操作。 1. **创建二叉树** 创建一个二叉树首先需要定义二叉树节点的数据结构。在链表...
二叉树的操作算法
11-28
遍历是二叉树操作的核心部分，主要有三种方法：前序遍历、中序遍历和后序遍历。这些遍历方法可以通过递归或栈辅助实现。例如，前序遍历的递归实现为： ```cpp template void BiTree<T>::preorderTraversal...
C++二叉树基本操作实验报告.doc
06-14
这一部分是实验的基础，也是最能体现二叉树基本操作的地方。 最后，通过上述程序设计与分析，我们可以总结出C++实现二叉树基本操作的流程和方法，这不仅涉及到二叉树结构的建立和遍历，还包括如何递归地访问树节点...
java 二叉树_LeetCode每日一题--104. 二叉树的最大深度(Java)
weixin_39617252的博客
12-02 74
DailyChallenge104. 二叉树的最大深度Easy20200728Description给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。说明: 叶子节点是指没有子节点的节点。[链接：https://leetcode-cn.com/problems/maximum-depth-of-binary-treeSolution二叉树，一般就是先序遍历会简...
数据结构（C语言）：二叉树的创建、遍历、销毁等操作
weixin_48922642的博客
08-10 643
tree.h #ifndef _TREE_H_ #define _TREE_H_ #include <stdio.h> #include <stdlib.h> typedef struct node { char data; struct node *pL; struct node *pR; }BTNode; extern BTNode *createBinTree(); extern void preOrder(BTNode *pRoot); extern void
数据结构——二叉树的基本操作（二）
yxl_d的博客
10-29 2633
一、实验目的及要求 1.理解二叉树的基本概念和特点 2.掌握二叉树的链式存储结构 3.掌握二叉树的基本操作 4.掌握二叉树遍历操作 二、实验内容（或实验原理、实验拓扑） 1.实现二叉树的如下操作，先序遍历、中序遍历和后序遍历的递归算法，二叉树如下图所示。(采用二叉链存储结构实现) (1)采用括号表示法，构建如下二叉树，并输出二叉树b； (2)采用递归算法，输出二叉树的先序序列；（参考课本212页代...
每天一点数据结构之二叉树的插入与创建
lavender21的博客
05-25 4633
每天一点数据结构之二叉树的插入与创建 二叉树的插入： 1.判断树是否为空，如果为空则直接插入当前结点成为根结点 2.若根不为空，则判断是否小于根 3.小于根插入左子树 4.大于根插入右子树 5.以此循环下去，插入完成退出   //二叉树的插入 BinaryTree.prototype.insert = function(data) { //在这里写入代码 var
【数据结构】树（五）—— 二叉排序树（C语言版）
热门推荐
haoweixl的博客
09-05 1万+
【数据结构】二叉排序树（C语言版）前言一、二叉排序树的定义二、二叉排序树的性质三、二叉排序树的操作二叉排序树常用存储结构二叉排序树的查找(递归实现)查找"二叉树T"中键值为 key 的节点(非递归实现)查找"二叉树T"中键值为 key 的节点二叉排序树的插入二叉排序树的创建二叉排序树的删除四、二叉树的查找性能分析应用区分：（与二分查找的应用区分）二叉排序树的构造树结构分析完整可运行代码 前言 二叉排序树(Binary Sort Tree,BST)又称为二叉查找树、二叉搜索树。与树型查找有关的结构有二叉排序树
二叉树的创建与基本操作
阿牛哥的博客
04-28 1722
二叉树的性质我就不多说了，毕竟是笔记，直接上一点干货（代码操作） 根据二叉树的性质，建立一个二叉树存储结构。 typedef char DataType; /*二叉树存储结构类型*/ typedef struct tonde{ DataType data; struct tonde *lchile,*rchile;//左孩子，右孩子指针 }BT; 创建一个二叉树，按二叉树带空指针的先序依次输入（解释：因为在创建时我要从根结点开始建立，并且返回这个树根结点，“树高万丈不忘根，人若辉煌不忘本嘛”
二叉树代码
weixin_44264668的博客
04-17 299
tree.h #ifndef __TREE_H #define __TREE_H #include <stdio.h> #include <stdlib.h> //声明描述节点的数据结构 typedef struct node { int data; //数据 struct node *left; //左子树地址 struct node *right; //右子树地址 }node_t; //声明描述整颗树的数据结构、 typedef struct tre
基于SSM的一线式酒店管理系统-su0v7503【附万字论文+PPT+包部署+录制讲解视频】.zip
最新发布
08-15
基于SSM的一线式酒店管理系统-su0v7503【附万字论文+PPT+包部署+录制讲解视频】.zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值