数据结构笔记3---树

最新推荐文章于 2024-05-22 10:59:33 发布
最新推荐文章于 2024-05-22 10:59:33 发布
阅读量175 收藏
点赞数 1
分类专栏： android 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37527943/article/details/78803610
版权

导读

1.树的简介及性质
2.树的创建，递归遍历（创建，层序插入元素，递归先中后序遍历）
3.树的非递归遍历（前中后序），层序遍历

树的简介及性质

完全二叉树的例子

完全二叉树反例

二叉树的性质

N0：叶节点数
N1：度数为1的节点数，以此类推

二叉树：N0=N2+1
m叉树：N0=1+N2+2N3+3N4+….+(m-1)Nm

树的创建，递归遍历

#include <iostream>
using namespace std;

typedef struct TreeNode *BinTree;
struct TreeNode{
    int data;
    BinTree Left;
    BinTree Right;
};

//树的节点类型要写在队列节点之前

typedef struct Node *node;
struct Node{
    BinTree data;//队列的数据类型应为BinTree
    node next;
};


typedef struct QNode *queue;
struct QNode{
    node front;
    node rear;
};


queue init(){
    node head=new Node;
    queue queue=new QNode;
    queue->front=queue->rear=head;
    head->next=NULL;
    return queue;
}


void Push(queue &queue,BinTree data){
    node node=new Node;
    node->data=data;
    node->next=queue->rear->next;
    queue->rear->next=node;
    queue->rear=queue->rear->next;
}


bool Isempty1(queue queue){
    bool flag;
    if(queue->front->next==NULL)
        flag=true;
    else flag=false;
    return flag;
}


BinTree Pop(queue &queue){
    BinTree result;
    if(Isempty1(queue)){
        cout<<"It's empty!"<<endl;
        return NULL;
    }
    else{
        node node;
        node=queue->front->next;
        queue->front->next=queue->front->next->next;
        result=node->data;
        delete(node);
        if(Isempty1(queue))
            queue->rear=queue->front;
        //此处if判断非常重要，目的是在空栈时让rear回到原位
        return result;
    }
}

//+++++++++++++++下边是针对树进行的操作++++++++++++++++++++++++++
//判空
bool Isempty(BinTree bintree){
    bool flag;
    if(bintree==NULL)
        flag=true;
    else flag=false;
    return flag;
}

//借助队列层序插入元素
void Insert(BinTree &bintree,int data){
    //如果还没有根节点，就创一个
    if(bintree==NULL){
        bintree=new TreeNode;
        bintree->data=data;
        bintree->Left=NULL;
        bintree->Right=NULL;
    }
    else{
        BinTree s=new TreeNode;
        //s是用来接收data的
        s->data=data;
        s->Left=NULL;
        s->Right=NULL;
        //创建一个队列并将树根入队
        queue queue;
        queue=init();
        Push(queue,bintree);
        while(!Isempty1(queue)){
            BinTree p=Pop(queue);
            if(p->Left==NULL){
                p->Left=s;
                break;
            }
            else if(p->Right==NULL){
                p->Right=s;
                break;
            }
            else{
                Push(queue,p->Left);
                Push(queue,p->Right);
            }
        }
    }
}

//递归先序遍历输出
void PreOrderTraversal(BinTree bintree){
    //有递归时，不要随便加语句(比如下边)，这是递归的特殊性
    //if(Isempty(bintree))
    //cout<<"It's empty"<<endl;
    if(!Isempty(bintree)){
        cout<<bintree->data<<" ";
        PreOrderTraversal(bintree->Left);
        PreOrderTraversal(bintree->Right);
    }
}

//递归中序遍历输出
void InOrderTraversal(BinTree bintree){
    if(!Isempty(bintree)){
        InOrderTraversal(bintree->Left);
        cout<<bintree->data<<" ";
        InOrderTraversal(bintree->Right);
    }
}

//递归后序遍历输出
void PostOrderTraversal(BinTree bintree){
    if(!Isempty(bintree)){
        PostOrderTraversal(bintree->Left);
        PostOrderTraversal(bintree->Right);
        cout<<bintree->data<<" ";
    }
}



int main(){
    BinTree bintree=NULL;
    for(int i=1;i<=7;i++)
     Insert(bintree,i);
    PreOrderTraversal(bintree);
    cout<<endl;
    InOrderTraversal(bintree);
    cout<<endl;
    PostOrderTraversal(bintree);
    cout<<endl;
    return 0;
}

输出结果
1 2 4 5 3 6 7
4 2 5 1 6 3 7
4 5 2 6 7 3 1
Program ended with exit code: 0

树的非递归遍历，层序遍历

#include <iostream>
using namespace std;

typedef struct TreeNode *BinTree;
struct TreeNode{
    int data;
    BinTree Left;
    BinTree Right;
};

//树的节点类型要写在队列节点之前

//++++++++++++++++以下是队列的创建过程+++++++++++++++++
typedef struct Node *node;
struct Node{
    BinTree data;//队列的数据类型应为BinTree
    node next;
};


typedef struct QNode *queue;
struct QNode{
    node front;
    node rear;
};


queue init(){
    node head=new Node;
    queue queue=new QNode;
    queue->front=queue->rear=head;
    head->next=NULL;
    return queue;
}


void Push(queue &queue,BinTree data){
    node node=new Node;
    node->data=data;
    node->next=queue->rear->next;
    queue->rear->next=node;
    queue->rear=queue->rear->next;
}


bool Isempty1(queue queue){
    bool flag;
    if(queue->front->next==NULL)
        flag=true;
    else flag=false;
    return flag;
}


BinTree Pop(queue &queue){
    BinTree result;
    if(Isempty1(queue)){
        cout<<"It's empty!"<<endl;
        return NULL;
    }
    else{
        node node;
        node=queue->front->next;
        queue->front->next=queue->front->next->next;
        result=node->data;
        delete(node);
        if(Isempty1(queue))
            queue->rear=queue->front;
        //此处if判断非常重要，目的是在空栈时让rear回到原位
        return result;
    }
}
//+++++++++++++++下边是堆栈的创建过程++++++++++++++++++++++++++++
typedef struct SNode *snode;
struct SNode{
    BinTree data;//栈的数据类型应为BinTree
    snode next;
};

//创建
snode init2(){
    snode Stack=new SNode;
    Stack->next=NULL;
    return Stack;
}

//入栈
void Push(snode &Stack,BinTree data){
    snode s=new SNode;
    s->data=data;
    s->next=Stack->next;
    Stack->next=s;
}

//出栈
BinTree Pop(snode &Stack){
    snode s;
    BinTree result;
    if(Stack->next==NULL){
        cout<<"It's empty!"<<endl;
        return NULL;
    }
    else{
        s=Stack->next;
        Stack->next=Stack->next->next;
        result=s->data;
        delete(s);
        return result;
    }

}

//判空
bool Isempty2(snode Stack){
    bool flag;
    if(Stack->next==NULL)
        flag=true;
    else flag=false;
    return flag;
}
//+++++++++++++++下边是针对树进行的操作++++++++++++++++++++++++++
//判空
bool Isempty(BinTree bintree){
    bool flag;
    if(bintree==NULL)
        flag=true;
    else flag=false;
    return flag;
}

//借助队列层序插入元素
void Insert(BinTree &bintree,int data){
    //如果还没有根节点，就创一个
    if(bintree==NULL){
        bintree=new TreeNode;
        bintree->data=data;
        bintree->Left=NULL;
        bintree->Right=NULL;
    }
    else{
        BinTree s=new TreeNode;
        //s是用来接收data的
        s->data=data;
        s->Left=NULL;
        s->Right=NULL;
        //创建一个队列并将树根入队
        queue queue;
        queue=init();
        Push(queue,bintree);
        while(!Isempty1(queue)){
            BinTree p=Pop(queue);
            if(p->Left==NULL){
                p->Left=s;
                break;
            }
            else if(p->Right==NULL){
                p->Right=s;
                break;
            }
            else{
                Push(queue,p->Left);
                Push(queue,p->Right);
            }
        }
    }
}

//借助堆栈非递归先序遍历输出

void PreOrderTraversal(BinTree bintree){
    BinTree T=bintree;
    snode Stack=init2();
    while(T||!Isempty2(Stack)){
    //一直走到树的左边，输出后入栈
        while(T){
            cout<<T->data<<" ";
            Push(Stack,T);
            T=T->Left;
        }
    //下边语句的作用是转向树的右边分支
        if(!Isempty2(Stack)){
            T=Pop(Stack);
            T=T->Right;
        }
    }
}

//借助堆栈非递归中序遍历输出

void InOrderTraversal(BinTree bintree){
    BinTree T=bintree;
    snode Stack =init2();
    while(T||!Isempty2(Stack)){
        //一直走到树的最左边
        while(T){
            Push(Stack,T);
            T=T->Left;
        }
        //出栈并输出
        if(!Isempty2(Stack)){
            T=Pop(Stack);
            cout<<T->data<<" ";
            T=T->Right;
        }
    }
}

//借助堆栈非递归后序遍历输出
void PostOrderTraversal(BinTree bintree){
    BinTree T=bintree;
    snode Stack1=init2();
    snode Stack2=init2();
    if(T==NULL) return;
    else Push(Stack1,T);
//后序遍历三步走
//1:将栈Stack1的Top压入栈Stack2
//2:检查栈Stack1的Top有没有左子，有的话压入栈Stack1
//3:检查栈Stack2的Top有没有右子，有的话压入栈Stack2
//当栈Stack1空时，输出栈Stack2

    while(!Isempty2(Stack1)){
        T=Pop(Stack1);
        Push(Stack2,T);
        if(T->Left!=NULL)
            Push(Stack1,T->Left);
        if(T->Right!=NULL)
            Push(Stack1,T->Right);
    }
    while(!Isempty2(Stack2))
        cout<<Pop(Stack2)->data<<" ";
}

//借助队列层序遍历输出
void LevelOrderTraversal(BinTree bintree){
    BinTree T=bintree;
    queue queue=init();
    if(Isempty(T)) return;
    else Push(queue,T);
//层序遍历三步走：
//1 如果队列不空出队
//2 如果出队元素左子不空，将左子入队
//3 如果出队元素右子不空，将右子入队
    while(!Isempty1(queue)){
        T=Pop(queue);
        cout<<T->data<<" ";
        if(T->Left!=NULL)
            Push(queue,T->Left);
        if(T->Right!=NULL)
            Push(queue,T->Right);
    }
}

int main(){
    BinTree bintree=NULL;
    for(int i=1;i<=7;i++)
     Insert(bintree,i);
    PreOrderTraversal(bintree);
    cout<<endl;
    InOrderTraversal(bintree);
    cout<<endl;
    PostOrderTraversal(bintree);
    cout<<endl;
    LevelOrderTraversal(bintree);
    cout<<endl;
    return 0;
}

输出结果

1 2 4 5 3 6 7
4 2 5 1 6 3 7
4 5 2 6 7 3 1
1 2 3 4 5 6 7
Program ended with exit code: 0

hala-22
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《数据结构学习笔记-第八篇》- 树与森林
03-31
关于树的笔记
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 39万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
数据结构与算法学习笔记
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
866数据结构笔记 - 第五章 树和二叉树
qq_45331246的博客
10-20 2131
866数据结构、湖南大学考研、树和二叉树
数据结构--笔记汇总
会思想的苇草i的博客
02-20 790
这里是个人学习数据结构的一些笔记感悟，在此推荐青岛大学–王卓老师的数据结构课程视频，个人认为是比较通俗易懂的。 数据结构-青岛大学王卓 搭配笔记可以帮助更快掌握数据结构这门课程的相关知识点。 数据结构（C语言版）-- 数据结构基础 数据结构（C语言版）-- 线性表笔记 数据结构（C语言版）-- 栈和队列笔记 数据结构（C语言版）-- 串、数组和广义表笔记 数据结构（C语言版）-- 树和二叉树笔记 数据结构（C语言版）-- 图笔记 数据结构（C语言版）-- 查找笔记 数据结构（C语言版）-- 排序笔记 数据结
《数据结构学习笔记---第八篇》--- 王道的树与森林手写笔记
yl1509797225的博客
03-31 663
树，森林，二叉树，树与森林转化，二叉树的遍历，树的遍历，完全二叉树与满二叉树，树的存储（孩子兄弟表示法），树的链式存储
Java数据结构与算法-笔记-代码-课件-资料
05-17
稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与...斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)等...
数据结构与算法-学习笔记 Java 版.zip
01-15
基本操作：针对每种数据结构，定义了一系列基本的操作，包括但不限于插入、删除、查找、更新、遍历等，并分析这些操作的时间复杂度和空间复杂度。 算法： 算法设计：研究如何将解决问题的步骤形式化为一系列指令，...
数据结构复习笔记-树和二叉树推荐.pdf
03-13
数据结构复习笔记-树和二叉树推荐.pdf
数据结构笔记：树
12-14
分类目录——数据结构笔记 概念 树是一种抽象数据结构（ADT）或是实现这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合。它是由n（n>=1）个有限节点组成一个具有层次关系的集合。把它叫做树是因为它...
P2【练习力扣933】【数据结构】【队列queue】C++版
qq_50891451的博客
05-18 485
，范围是 [-2900,100]，返回 2。]，范围是 [-2999,1]，返回 1。]，范围是 [1,3001]，返回 3。]，范围是 [2,3002]，返回 3。类来计算特定时间范围内最近的请求。的调用都使用比之前更大的。
数据结构——二叉树知识点详解！
hu_ju_hong的博客
05-15 665
数据结构二叉树概念超详细讲解！同时也是学习数据结构——堆的必修课！
P6【力扣144，94，145】【数据结构】【二叉树遍历】C++版
最新发布
qq_50891451的博客
05-22 405
从根节点开始遍历，并将根节点入栈，再遍历他的左子树，并依次入栈，直到该结点没有左子树。判断这个结点是否有右子树，如果没有，则将该结点弹出栈，并记录结点值。如果有则继续从他的右子树进行遍历，同时记录该结点的右子树是否遍历过，如果遍历过，则弹栈并记录结点值。时间复杂度：O（N）每个结点会遍历一次且只遍历一次。空间复杂度：O（N）栈至多会存放所有树节点。
P0【知识点】【数据结构】【数组Array】讲解C++版
qq_50891451的博客
05-16 246
大O表示法 O(1) < O(logN) < O(N) < O(NlogN) < O(N^2) < O(2^N)at() 这个方法返回的是一个引用，可以吧一个常量 int 赋值给它。数组索引（Access）：是通过数组的下标去找这个元素。大O表示法 O(1) < O(N) < O(N^2)数组搜索（Search）：是找这个元素的位置（索引）3.插入 Insert O(N)4.删除 Delete O(N)1.访问access O(1)2.搜索search O(N)【485】最大连续1的个数。
数据结构——AVL树
mastershooter的博客
05-16 986
在结点的定义中，我们直接定义成KV模型的结点，并新增一个平衡因子，还有一个_parent指针，也就是说，该结点拥有三个指针+一对键值对+一个平衡因子，在初始化时指针都初始化为空，平衡因子设定成0。//左子树指针//右子树指针//每个结点都包含了一个父结点地址//键值对int _bf;//平衡因子//构造函数, _kv(kv), _bf(0){}
P6【知识点】【数据结构】【树tree】C++版
qq_50891451的博客
05-22 111
普通二叉树：每个结点最多两个孩子满二叉树：除了叶子结点，每个节点都有两个孩子，且叶子节点在同一层上完全二叉树：从树的根节点，从上到下，从左到右依次填满节点形成的二叉树。
图论算法＜六＞：数据结构之图Graph详解及代码实现
欧特GO
05-16 719
数据结构之图Graph详解及代码实现,包括概念、术语、基础实现代码、BFS/DFS。
数据结构 之 Map & Set
AUGENSTERN_dc的博客
05-18 963
Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。以前常见的 搜索方式有： 直接遍历，时间复杂度为O(N)，元素如果比较多效率会非常慢 二分查找，时间复杂度为,但搜索前必须要求序列是有序的 上述排序比较适合静态类型的查找，即一般不会对区间进行插入和删除操作了，而现实中的查找比如： 根据姓名查询考试成绩 通讯录，即根据姓名查询联系方式 不重复集合，即需要先搜索关键字是否已经在集合中 可能在查找时进行一些插入和删除的操作，即动态查找，那上述两种方式就不太适合了，本
P4【知识点】【数据结构】【哈希表】C++版
qq_50891451的博客
05-20 747
此博客参考。
数据结构 树学习笔记
07-28
而引用\[3\]提到了一个关于数据结构与算法基础的学习资源，可以通过观看《推荐学习-数据结构与算法基础》这个视频来深入学习树的相关知识。 #### 引用[.reference_title] - *1* [数据结构学习笔记]...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值