数据结构——二叉树（BinaryTree）

最新推荐文章于 2022-01-03 22:29:40 发布
最新推荐文章于 2022-01-03 22:29:40 发布
阅读量315 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 二叉树 队列 链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ymj68520/article/details/118786197
版权

二叉树

队列
栈

（1）定义

// BinaryTree
// 1. 二叉树第 i 层最多有2^(i-1)个节点
// 2. 深度为k的二叉树最多有2^k - 1 个节点
// 3. 对任意的二叉树T，如果终端节点数为n0 度为2的结点数为n2 则有 n0 = n2 + 1
// 完全二叉树
// 4. 具有n个节点的二叉树的深度为 floor(log2(n))+1
// 5. (1) 节点i的parent为 floor(i/2)
// 5. (2) 若2i>n,则节点无leftchild否则leftchild是2i
// 5. (3) 若2i+1>n,则节点无rightchild 否则 是 2i+1
// 节点i所处的层数为 floor(log2(i+1))+1

（2）二叉树定义的基本操作

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

#define MAX_TREE_SIZE 100   // 最大节点数

// 顺序存储就是以数组的形式存储，根节点为[0]或者[1]，但是这个只适用于完全二叉树，一般的
// 二叉树会造成内存浪费。因此使用链式结构，即链表。

#define TElemType int
typedef struct BiTNode{
    TElemType data; // 节点的值
    struct BiTNode *lchile,*rchild; // 左右孩子指针
}BiTNode,*BiTree;

#define Status bool
#define OK true
#define ERROR false
#define Nil 0               // 定义TElemType的空
#define ClearBiTree DestroyBiTree  // 清空与销毁操作一样

void Visit(TElemType T){
    printf("%d",T);
}

// 构造空二叉树
void InitBiTree(BiTree T){
    T = NULL;
}
// 若二叉树存在，则销毁二叉树
void DestroyBiTree(BiTree T){
    if(T){  // 非空树
        DestroyBiTree(T->lchile);   // 递归
        DestroyBiTree(T->rchild);
        free(T);    // 删除根节点
        T = NULL;   // 空指针赋0
    }
}
// 若二叉树存在，则对节点执行操作Visit() 
// 先序递归遍历T，对每个节点调用Visit一次且仅一次
void PreOrderTraverse(BiTree T,void(*Visit)(TElemType)){
    if(T){  // T非空
        Visit(T->data);                     // 先访问根节点
        PreOrderTraverse(T->lchile,Visit);  // 遍历左子树
        PreOrderTraverse(T->rchild,Visit);  // 遍历右子树        
    }
}
// 中序递归遍历T，对每个节点调用Visit 一次仅且一次
void InOrderTraverse(BiTree T, void(*Visit)(TElemType)){
    if(T){  // T非空
        PreOrderTraverse(T->lchile,Visit);
        Visit(T->data);
        PreOrderTraverse(T->rchild,Visit);
    }
}
// 后序递归遍历T，对每个节点调用Visit 一次仅且一次
void LastOrderTraverse(BiTree T,void(*Visit)(TElemType)){
    if(T){  // T非空
        PreOrderTraverse(T->lchile,Visit);
        PreOrderTraverse(T->rchild,Visit);
        Visit(T->data);
    }
}
// 判断二叉树是否为空
Status BiTreeEmpty(BiTree T){
    if(T)
        return false;
    else
        return true;
}
// 返回二叉树的深度
int BiTreeDepth(BiTree T){
    int i,j;
    if(!T)
        return 0;   // 空树深度为0
    i = BiTreeDepth(T->lchile);
    j = BiTreeDepth(T->rchild);
    return i>j?i+1:j+1;
}
// 返回二叉树的根
TElemType Root(BiTree T){
    if(BiTreeEmpty(T))
        return Nil;
    else    // 树非空
        return T->data;
}
// 返回指针p指向的节点的值
TElemType Value(BiTree p){
    return p->data;
}
// 给p所指节点赋值为value
void Assign(BiTree p,TElemType value){
    p->data = value;
}

（3）使用队列的二叉树

typedef BiTree QElemType;   // 定义队列元素为二叉树的指针类型
#include "../queue/queue.h"

// 返回二叉树T中指向元素s的结点的指针
BiTree Point(BiTree T,TElemType s){
    LinkQueue q;
    QElemType a;
    if(T){  // 树非空
        InitQueue(&q);   // 初始化队列
        EnQueue(&q,T);   // 根指针入队
        while(!QueueEmpty(q))   // 队非空
        {
            DeQueue(&q,&a);     // 出队，队列元素赋值给a
            if(a->data == s){   // a所指节点的值为s
                DestroyQueue(&q);   // 销毁队列
                return a;
            }
            if(a->lchile)   // 有leftchild
                EnQueue(&q,a->lchile);  // 入队
            if(a->rchild)
                EnQueue(&q,a->rchild);
        }
        DestroyQueue(&q);   // 销毁队列
    }
    return NULL;    // 二叉树中没有元素为s的结点
}
// 返回e的leftchild
TElemType LeftChild(BiTree T, TElemType e){
    BiTree a;
    if(T){  // T非空
        a = Point(T,e);     // a是指向节点e的指针
        if(a && a->lchile)  // T中存在节点e且e有leftchild
            return a->lchile->data;
    }
    return Nil;
}
TElemType RightChild(BiTree T,TElemType e){
    BiTree a;
    if(T){
        a = Point(T,e);
        if(a && a->rchild)
            return a->rchild->data;
    }
    return Nil;
}
// 二叉树T存在，且p指向T中某个节点，LR为0或1
// 根据LR的值，删除T中p所指节点的左子树或右子树
Status DeleteChild(BiTree p, int LR){
    if(p){      // 非空
        if(LR == 0){    // 删除左子树
            ClearBiTree(p->lchile);
        }
        else if(LR == 1)
            ClearBiTree(p->rchild);
        return OK;
    }
    return ERROR;
}
// 若二叉树T存在，Visit是对节点的相应操作函数
// 层序递归遍历T(利用队列), 对每个节点调用Visit一次仅且一次
void LeveOrderTraverse(BiTree T,void(*Visit)(TElemType)){
    LinkQueue q;
    QElemType a;
    if(T){
        InitQueue(&q);   // 初始化队列
        EnQueue(&q,T);   // 根指针入队
        while(!QueueEmpty(q)){  // 队列不空
            DeQueue(&q,&a);     // 出队元素（指针），赋给a
            Visit(a->data);
            if(a->lchile)
                EnQueue(&q,a->lchile);
            if(a->rchild)
                EnQueue(&q,a->rchild);
        }
        printf("\n");
        DestroyQueue(&q);
    }
}
// 按先序次序输入二叉树节点的值
void CreatBiTree(BiTree *T){
    TElemType ch;
    scanf("%d",&ch);
    if(ch == Nil){
        T = NULL;
    }
    else    // 节点非空
    {
        *T = (BiTree)malloc(sizeof(BiTNode));    // 生成根节点
        if(!(*T))
            exit(EXIT_FAILURE);
        (*T)->data = ch;
        
        CreatBiTree(&(*T)->lchile);

        CreatBiTree(&(*T)->rchild);
    }
}
// 二叉树T存在，e是T中某个节点
// 若e是T的非根节点，则返回他的parent否则返回“空”
TElemType Parent(BiTree T,TElemType e){
    LinkQueue q;
    QElemType a;
    if(T){  // 非空
        InitQueue(&q);
        EnQueue(&q,T);
        while(!QueueEmpty(q)){
            DeQueue(&q,&a);
            if(a->lchile && a->lchile->data == e ||
                a->rchild && a->rchild->data == e)
                    return a->data;
            else{   // 未找到
                if(a->lchile)
                    EnQueue(&q,a->lchile);
                if(a->rchild)
                    EnQueue(&q,a->rchild);
            }
        }
    }
    return Nil;
}
// 二叉树T存在，e是某个节点
// 返回e的leftsibling。若e是T的leftchild或无leftchild，则返回空
TElemType LeftSibling(BiTree T,TElemType e){
    TElemType a;
    BiTree p;
    if(T){
        a = Parent(T,e);
        if(a!=Nil){
            p = Point(T,e);
            if(p->lchile && p->rchild && p->rchild->data==e)    // 存在且右是e
                return p->lchile->data;         // 返回p的leftchild（e的左兄弟）
        }
    }
    return Nil;
}
// 返回e的rightsibling
TElemType RightSibling(BiTree T,TElemType e){
    TElemType a;
    BiTree p;
    if(T){
        a = Parent(T,e);
        if(a!=Nil){
            p = Point(T,a);
            if(p->lchile && p->rchild &&p->lchile->data == e)
                return p->rchild->data;
        }
    }
    return Nil;
}
// 二叉树T存在，p指向T中某个节点，LR为0或1，非空二叉树c与T不相交且右子树为空
// 根据LR为0或1，插入c为T中p所指节点的左子树或右子树。即p点所指节点的原有左右子树
// 成为c的右子树
Status InsertChild(BiTree p,int LR,BiTree c){
    if(p){
        if(LR == 0){    // 把二叉树c插为p所指的左子树
            c->rchild = p->rchild;  // p所指节点的原有左子树成为c的右子树
            c->lchile = c;  // 二叉树c成为p的左子树
        }
        else{
            c->rchild = p->rchild;
            p->rchild = c;
        }
        return OK;
    }
    return ERROR;       // p空

}

(3) 使用栈的二叉树

// 定义栈元素为二叉树的指针类型
typedef BiTree SElemType;
#include "../Stack/stack.h"

// 采用二叉链表存储结构，Visit是对元素操作的函数
// 中序遍历二叉树T的非递归算法（利用栈），对每个元素调用VIsit
void InOrderTraverse2(BiTree T,void(*Visit)(TElemType)){
    SqStack S;
    BiTree p;
    InitStack(&S);
    Push(&S,T);         // T进栈，无论空否
    while(!StackEmpty(S)){      // 栈不空
        while(GetTop(S,&p)&&p)  // 栈顶元素不空
            Push(&S,p->lchile); // 向左走到尽头，入栈leftchild
        Pop(&S,&p);         // 空指针退栈，退掉最后入栈的空指针
        if(!StackEmpty(S)){ // 访问节点，向右一步
            Pop(&S,&p);     // 弹出栈顶元素（非空）
            Visit(p->data); // 访问刚弹出的结点的数据
            Push(&S,p->rchild); // 入栈rightchild
        }
    }
    printf("\n");
    DestroyStack(&S);    // 销毁栈
}
沉香°う
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——二叉树BinaryTree基本功能大全及代码实现（递归、非递归遍历、深度、结点数）
Jayphone17的博客
10-05 1122
一、需求分析与功能描述 现代社会生活中，计算机扮演着重要角色，而随着计算机运行速度的不断加快，对数据的处理能力也日益增强，因此，程序所涉及的数据很多，如何科学有效的对数据进行操作，使得计算机的时间和空间利用率最高是一个问题。针对这样的问题，我选择了二叉树对数据的各种操作作为我的课程设计主题，希望通过二叉树来提高对数据的处理能力，促进对数据结构课程的理解。 在二叉树的应用中，常常要求在树中查找...
数据结构——二叉树
观则明的博客
08-24 512
数据结构——二叉树
BinaryTree
03-22
This is a binary tree search implementation.
BinaryTree(二叉树)
ding7530的博客
08-30 184
　　我认为二叉树的递归实现体现了递归思想的一些重要性质，如果对递归的理解不够的话，想利用递归来实现是很费劲的(实际上我现在都还有些懵...)，虽然会用，但一些地方不能弄清楚原因。 　　经过几天的学习，看了许多前辈们的代码，综合后总算实现了一个二叉查找树，对创建和插入等基本操作上是弄明白并实现了，就是删除还有些细节不是很明白，因此，留着慢慢理解。 　　Head File： #if...
java-二叉树binaryTree
08-05
2.binaryTree树 标准的二叉树。 实现了各种算法，增删查改等等
数据结构-二叉树(Binary Tree)
I will not forget who I love.
01-02 537
#include #include #include #define LIST_INIT_SIZE 10 #define LISTINCREMENT 100 #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define TRUE 1 #define FALSE 0 #define true 1 #define false 0 #d
Java数据结构——二叉树难点
NoBug
01-03 840
1. 难点一：二叉树的存储********* 2. 难点二：不止一种方法存储二叉树********* 3. 压缩存储，add************
广工数据结构实验——平衡二叉树
07-06
本实验“广工数据结构实验——平衡二叉树”着重探讨了一种特殊类型的数据结构，即平衡二叉树。平衡二叉树是二叉搜索树（Binary Search Tree, BST）的一个变体，它通过保持树的高度平衡来确保查找、插入和删除操作的...
数据结构——二叉树的基本操作（C语言，完整优美实现）
明宇逸风的博客
10-28 9558
串 文章目录串前言一、树是什么？二、该如何理解树？三、各类树的存在形式四、二叉树的遍历方式深度遍历先序遍历中序遍历后序遍历层次遍历五、二叉树的实现1.二叉树的实现1.1 引入库以及设置结构体1.2初始化二叉树1.3队列的基本操作实现1.4二叉树深度遍历的三种方法1.5层次遍历1.6求子叶个数以及结点个数1.7串的输出功能1.8主函数实现上述全部功能2.运行截图总结 前言 1.本文就介绍了数据结构中二叉树的五条性质以及二叉树的存储结构 2.二叉树的基本操作的编程实现，掌握二叉树的建立、先序，中序，后序遍
c语言二叉树学生成绩,二叉树C语言
weixin_31969181的博客
05-18 182
几乎报价http://blog.csdn.net/hopeyouknow/article/details/6740616。为了这细微的地方进行了修改。他能够执行。bitree.htypedef int Item;typedef struct node{struct node *lchild;struct node *rchild;Itemdata;}BiTNode, *BiTree;BiTree ...
重学数据结构系列之——平衡树之SB Tree（Size Blanced Tree）
weixin_33800593的博客
07-03 200
学习来源：计蒜客 平衡树 1.定义 对于每一个结点。左右两个子树的高度差的绝对值不超过1，或者叫深度差不超过1 为什么会出现这样一种树呢？ 假如我们依照1-n的顺序插入到二叉排序树中，那么二叉排序树就退化成了一个有序链表，效率大大减少。 2.有关概念 全部平衡树基本由下面三个特征组成： 1.自平衡条件 2.旋转操作 3.旋转的...
二叉树（BiTree）(递归与非递归法)
Sharing_Li的专栏
04-25 2545
二叉树的基本性质：         1.二叉树的第i层上最多有2^(i - 1)个结点。         2.在一棵深度为k的二叉树中，最多有2^k - 1个结点，最少有k个结点。         3.在一棵二叉树中，如果叶子结点的格式为n0，度为2的结点数为n2，则n0 = n2 + 1。         4.具有n个结点的完全二叉树深度为[log2 n] + 1。         5
五、【数据结构】二叉树(binary tree)的实现
天涯明月刀的博客
12-02 2442
本文使用C++实现二叉树数据结构，与之前实现的向量、列表、栈和队列不同，树是一种分层结构，虽然树是分层结构，但若附加某种约束，如遍历次序，则树结构也可以转变成线性次序，因此树属于半线性结构。树结构具有非常多的变种，在算法理论和实际应用中，各种树结构扮演着最为关键的角色。 另外，任何有根有序的多叉树，都能转变成二叉树，因此二叉树数据结构具有非常重要的地位。 两种特殊的二叉树:完全二叉树、满二叉树...
心中有“树”：数据结构之树详解
ln_acmc的博客
04-02 1134
文章目录前言（一）树的基础定义与表示1 树的定义2 树的图示3 树的逻辑结构表示法（二）二叉树1 二叉树定义2 二叉树示意图3 程序实现（1）节点定义（2）二叉树的先序遍历（3）二叉树非递归先序遍历（4）二叉树层序遍历（5）计算二叉树的深度4 二叉树算法设计题目1 查找元素为X的节点2 判断二叉树是否为完全二叉树（三）树1 树的存储结构2 存储结构图示3 树的先序遍历4 求树的深度（四）总结（五）参考文献 前言 树型结构是一类重要的非线性数据结构。其中以树和二叉树最为常用。树状结构在客观世界中广泛存在，如人
Size Balanced Tree(SBT树)整理
weixin_30414245的博客
11-29 558
不想用treap和Splay，那就用SB树把，哈哈，其实它一点也SB，厉害着呢。 先膜拜一下作者陈启峰。Orz 以下内容由我搜集整理得来。 一、BST及其局限性 二叉查找树（Binary Search Tree），也称有序二叉树（ordered binary tree）,排序二叉树（sorted binary tree），是指一棵空树或者具有下列性质的二叉树： 1.若任意...
替换所有与pattern匹配的子树（递归算法，深拷贝）
m0_52045186的博客
06-11 869
void BinaryTree<T>::replaceAll(BinaryTree<T>& pattern, BinaryTree<T>& bitree) { replaceall(this->root, pattern.root, bitree); } template<class T> bool BinaryTree<T>::replace(BinaryNode<T>* p, BinaryNode<T&
以中根和后根遍历序列构造二叉树，替换所有与pattern匹配的子树为bitree。（栈）
qq_45656671的博客
09-26 1708
以中根和后根遍历序列构造二叉树，替换所有与pattern匹配的子树为bitree。 public class BinaryTree { public BinaryNoderoot; public BinaryTree() { this.root = null; } public boolean isEmpty() //判断是否是空 { return this.root == null; } public String toString()//输出带空子树先跟序列 { return toStri
二叉树遍历与重建：清华版数据结构解析
"根据遍历序列求二叉树-数据结构（清华大学版）——树和二叉树" 在计算机科学中，树是一种非线性数据结构，它由若干个节点构成，每个节点可以有零个或多个子节点。在树和二叉树的领域里，遍历是重要的操作之一，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值