二叉树

最新推荐文章于 2022-05-01 12:47:37 发布
最新推荐文章于 2022-05-01 12:47:37 发布
阅读量510 收藏
点赞数
分类专栏： 数据结构 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43353348/article/details/102826251
版权

一、二叉树定义[以下数据来自百度百科]

二叉树是每个结点最多有两个子树的树结构。
二叉树有5种形态，分别是

  • 空二叉树【没有结点】

  • 只有根节点的二叉树

  • 只有左子树

  • 只有右子树

  • 完全二叉树
    二叉树的五种形态
    按其类型可以分为

  • 完全二叉树【每层的结点树达到了其最大值】

  • 满二叉树【除叶结点外其他结点都有左右结点，且叶结点都处于最底层】

  • 平衡二叉树【AVL树，左右子树的高度差不超过1】
    相关名词：

  • 树的结点（node）：包含一个数据元素及若干指向子树的分支；

  • 孩子结点（child node）：结点的子树的根称为该结点的孩子；

  • 双亲结点：B 结点是A 结点的孩子，则A结点是B 结点的双亲；

  • 兄弟结点：同一双亲的孩子结点； 堂兄结点：同一层上结点；

  • 祖先结点: 从根到该结点的所经分支上的所有结点

  • 子孙结点：以某结点为根的子树中任一结点都称为该结点的子孙

  • 结点层：根结点的层定义为1；根的孩子为第二层结点，依此类推；

  • 树的深度：树中最大的结点层

  • 结点的度：结点子树的个数【度只有0，1，2三种情况】

  • 树的度： 树中最大的结点度。

  • 叶子结点：也叫终端结点，是度为 0 的结点；

  • 分枝结点：度不为0的结点；

  • 有序树：子树有序的树，如：家族树；

  • 无序树：不考虑子树的顺序

二、二叉树性质

  1. 在二叉树的第ｉ（ｉ>=１）层最多有２＾(ｉ - １)个结点。
  2. 深度为k(k>=0)的二叉树最少有k个结点，最多有２＾ｋ－１个结点。
  3. 对于任一棵非空二叉树，若其叶结点数为n0，度为2的非叶结点数为n2，则ｎ0 = ｎ2 ＋１。
  4. 具有n个结点的完全二叉树的深度为int_UP（log(2，ｎ+1)）。
  5. 如果将一棵有n个结点的完全二叉树自顶向下，同一层自左向右连续给结点编号１，２，３，．．．．．．，ｎ，然后按此结点编号将树中各结点顺序的存放于一个一维数组，并简称编号为i的结点为结点i（ ｉ>=１ && ｉ<=ｎ）,则有以下关系：
    （1）若 ｉ= 1，则结点i为根，无父结点；若 ｉ> 1，则结点 i 的父结点为结点int_DOWN（ｉ / ２）;
    （2）若 ２＊ｉ <= ｎ，则结点 ｉ 的左子女为结点 ２＊ｉ；
    （3）若２＊ｉ＜＝ｎ，则结点ｉ的右子女为结点２＊ｉ＋１；
    （4）若结点编号ｉ为奇数，且ｉ！＝１，它处于右兄弟位置，则它的左兄弟为结点ｉ－１；
    （5）若结点编号ｉ为偶数，且ｉ！＝ｎ，它处于左兄弟位置，则它的右兄弟为结点ｉ＋１；
    （6）结点ｉ所在的层次为 int_DOWN（log（2，ｉ））＋１。

三、二叉树的常见算法

3.1 先序遍历

先访问本结点，再访问左结点，右结点。一个典型特征是根节点在第一位

public List<Object> preOrder(TreeNode node,List<Object> list){
        if(node!=null){
            list.add(node);
            preOrder(node.getLeftTr(),list);
            preOrder(node.getRightTr(),list);
        }
        return list;
    }

3.2 中序遍历

先访问左结点，再访问本结点，右结点。特征就是根节点居中【完全二叉树】
如果是有序二叉树，那么使用该排序方式可以大小有序的打印该树。

public List<Object> midOrder(TreeNode node,List<Object> list){
        if(node!=null){
            midOrder(node.getLeftTr(),list);
            list.add(node);
            midOrder(node.getRightTr(),list);
        }
        return list;
    }

3.3 后续遍历

先访问左结点，再访问右结点，本结点。根节点在最后一位

 public List<Object> lastOrder(TreeNode node,List<Object> list){
        if(node!=null){
            lastOrder(node.getLeftTr(),list);
            lastOrder(node.getRightTr(),list);
            list.add(node);
        }
        return list;
    }

3.4 层次遍历

从根节点（第一层）开始遍历

 public List<Object> rankOrder(TreeNode node,List<Object> list){
        Queue<TreeNode> q= Queues.newArrayDeque();
        q.offer(node);
        while(!q.isEmpty()){
            TreeNode n=q.poll();
            if(n!=null){
                list.add(n);
                if(n.hasLeftTr()){
                    q.offer(n.getLeftTr());
                }
                if(n.hasRightTr()){
                    q.offer(n.getRightTr());
                }
            }
        }

        return list;
    }

3.5 有序二叉树增加节点

从根节点开始遍历，若lnode<newNode<node ,则插入左子树，反之则右子树。遍历到子树的页结点，最后赋值。

public void addNode(TreeNode newNode){
        if(newNode.compareTo(this)<0){//左边
            if(this.leftTr==null){
                this.leftTr=newNode;
            }else{
                this.leftTr.addNode(newNode);
            }
        }else{
            if(this.rightTr==null){
                this.rightTr=newNode;
            }else{
                this.rightTr.addNode(newNode);
            }
        }
    }

3.6 有序二叉树删除结点

删除结点较与增加结点会更复杂一点，涉及到删除结点的子树的位置调换。
删除结点分为以下四种情况
1、根节点，特殊处理
2、删除结点为叶子节点：直接将删除结点的父节点的左 或者右结点置为null
3、删除结点只有左结点：需将删除结点的左子树，移到删除结点的父结点的右结点上
4、删除结点有右结点：需要判断右结点的子树的最小结点，并将最小结点的右子树移到删除结点的父节点的右子树

public void delete(TreeNode node){
        TreeNode x=find(node);
        TreeNode parent=findParent(x);
        if(!x.hasLeftTr()|| !x.hasRightTr()){//删除节点为叶子节点
            if(parent==null){//根节点
                this.setData(null);
            }else{
                if(parent.hasLeftTr()&& parent.getLeftTr().equals(x)){
                    parent.setLeftTr(null);//如果删除节点在父节点的左侧
                }
                if(parent.hasRightTr() && parent.getRightTr().equals(x)){
                    parent.setRightTr(null);//如果删除节点在父节点的右侧
                }
            }

        }
        if(x.hasLeftTr() &&!x.hasRightTr()){//删除的节点有左叶节点，没有右叶节点
            if(parent==null){
                this.setData(x.getLeftTr().getData());
                this.setLeftTr(x.getLeftTr().getLeftTr());
            }else{
                if(parent.hasLeftTr() && parent.getLeftTr().equals(x)){
                    parent.setLeftTr(x.getLeftTr());
                }if(parent.hasRightTr() && parent.getRightTr().equals(x)){
                    parent.setRightTr(x.getLeftTr());
                }
            }

        }
        if(x.hasRightTr()){//有右叶节点
            TreeNode minNode=x.getRightTr().finMinNode();
            parent=this.findParent(minNode);
            if(minNode.equals(x.getRightTr())){
                parent.setRightTr(minNode.getRightTr());
            }else{
                parent.setLeftTr(minNode.getRightTr());
            }
            x.setData(minNode.getData());
        }

    }

3.7 查找结点

从根结点开始遍历，才用3.1-3.4的方法均可以
也可以使用迭代遍历

 public  TreeNode find(TreeNode node){
        if(this==null){
            return null;
        }
        else if(this.compareTo(node)<0){
            return this.getRightTr().find(node);
        }else if(this.compareTo(node)>0){
            return this.getLeftTr().find(node);
        }
        return this;
    }

3.8 查找父结点

 public TreeNode findParent(TreeNode node1){

        if(this!=null && (node1.equals(this.getLeftTr()) || node1.equals(this.getRightTr()))){
            return this;
        }
        TreeNode parent=null;
        if(this.hasLeftTr()){
            parent=this.getLeftTr().findParent(node1);
            if(parent!=null){
                return parent;
            }
        }
        if(this.hasRightTr()){
            parent= this.getRightTr().findParent(node1);
            if(parent!=null){
                return parent;
            }
        }
         return parent;
    }

3.9 最小结点 or 最大结点

 public TreeNode finMinNode(){
        while (this.getLeftTr()!=null){
            return this.getLeftTr().finMinNode();
        }
        return this;
    }

    public TreeNode finMaxNode(){
        while(this.getRightTr()!=null){
            return this.getRightTr().finMaxNode();
        }
        return this;
    }

四、平衡树

平衡树是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树

4.1 Avl平衡树

参考资料：AVL树-自平衡二叉查找树(Java实现)
参考资料：手把手教，手写AVL树

4.2实现

4.2.1 左旋
 public AvlTreeNode rotateLeft(AvlTreeNode node){
        AvlTreeNode parent=node.getParent();
        AvlTreeNode anoNode=node.getRightTr();
        if(parent!=null){
            if (node.equals(parent.getLeftTr())){
                parent.setLeftTr(anoNode);
            }
            if(node.equals(parent.getRightTr())){
                parent.setRightTr(anoNode);
            }
        }
        anoNode.setLeftTr(node);
        node.setRightTr(anoNode.getRightTr());
        anoNode.setParent(node);
        anoNode.setParent(parent);
        return anoNode;
    }
4.2.2 右旋
    public AvlTreeNode rotateRight(AvlTreeNode node){
        AvlTreeNode parent=node.getParent();
        AvlTreeNode anoNode=node.getLeftTr();
        if(parent!=null){
            if (node.equals(parent.getLeftTr())){
                parent.setLeftTr(anoNode);
            }
            if(node.equals(parent.getRightTr())){
                parent.setRightTr(anoNode);
            }
        }
        anoNode.setRightTr(node);
        node.setLeftTr(anoNode.getRightTr());
        //父节点
        node.setParent(anoNode);
        anoNode.setParent(parent);

        return anoNode;

    }
4.2.3 先左旋再右旋
 public AvlTreeNode rotateLeftRight(AvlTreeNode node){
        AvlTreeNode parent=node.getParent();
        if(parent!=null){
            if (node.equals(parent.getLeftTr())){
                parent.setLeftTr(node.getLeftTr());
            }
            if(node.equals(parent.getRightTr())){
                parent.setRightTr(node.getRightTr());
            }
        }
        node.setLeftTr(rotateLeft(node.getLeftTr()));
       return rotateRight(node);
    }
4.2.4 先右旋再左旋
public AvlTreeNode rotateRightLeft(AvlTreeNode node){
        AvlTreeNode parent=node.getParent();
        if(parent!=null){
            if (node.equals(parent.getLeftTr())){
                parent.setLeftTr(node.getLeftTr());
            }
            if(node.equals(parent.getRightTr())){
                parent.setRightTr(node.getRightTr());
            }
        }
       node.setRightTr( rotateRight(node.getRightTr()));
        return rotateLeft(node);
    }
丢了芯
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
正弦定理的博客
12-09 35万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
二叉树详解
weixin_59371851的博客
07-09 5万+
目录前言一、树的概念和结构1、树的概念2、树的表示 3、树在实际中的应用（表示文件系统的目录树结构）二、二叉树概念及结构1.概念 2、特殊的二叉树3、二叉树的性质4、二叉树的存储4.1顺序存储4.2链状存储 三、二叉树的顺序结构和实现1、二叉树的顺序结构2、堆的概念及结构3、堆的实现3.1堆的代码框架3.2堆的插入3.3堆的删除3.4堆的建立 3.5建堆的时间复杂度 4、堆的应用4.1堆排序 4.2TOP-K问题四、二叉树链式结构的实现 1、建二叉树2、二叉树的遍历2.1前序、中序以及后序遍历2.2层序遍历
python二叉树
惊鸿的博客
03-12 5615
二叉树特征定义 特征 树是一种 非线性的数据结构，，直观的看，他是数据元素（在树中称为结点）按分支关系组织起来的结构，很像自然界中的树那样，树结构在客观世界中广泛存在，如人类社会的族谱和各种社会组织机构都可以用树形象来表示。还有比如在编译程序的时候，它可以用来表示源程序的语法结构，又或者在数据库中，树型结构也是信息的重要组织形式之一。 总之：一切具有层次关系的问题都可以用树来描述。 定义 树（Tree）是n（≥0）个节点的有限集。在任意一棵树中： 1、有且仅有一个称为根（Root）的结点 2、当n&g
二叉树的基本操作
Daioo 随笔
04-21 12万+
一、实验目的 1、掌握二叉树的定义； 2、掌握二叉树的基本操作，如二叉树的建立、遍历、结点个数统计、树的深度计算等。 二、实验内容 （一）用递归的方法实现以下算法： 1、以二叉链表表示二叉树，建立一棵二叉树（算法5.3）； 2、输出二叉树的中序遍历结果（算法5.1）； 3、输出二叉树的前序遍历结果（见讲稿）； 4、输出二叉树的后序遍历结果（见讲稿）； 5、计算二叉树的深度（算法5.
【数据结构】——二叉树详解
atwdy的博客
07-28 5万+
二叉树(Binary Tree)是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树TTT有且仅有一个根结点；除根结点外的其余结点又可分为两个不相交的子集TLT_LTL​和TRT_RTR​，分别称为TTT的左子树和右子树，且TLT_LTL​和TRT_RTR​本身又都是二叉树。很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；
平衡二叉树
清风
05-01 4万+
1.定义 平衡二叉树，又称AVL树，用于解决二叉排序树高度不确定的情况，如果二叉排序树的子树间的高度相差太大，就会让二叉排序树操作的时间复杂度升级为O(n)，为了避免这一情况，为最坏的情况做准备，就出现了平衡二叉树，使树的高度尽可能的小，其本质还是一棵二叉搜索树。 平衡二叉树的性质： 左子树和右子树的高度之差的绝对值小于等于1 左子树和右子树也是平衡二叉树 为了方便起见，给树上的每个结点附加一个数字，给出该结点左子树与右子树的高度差，这个数字称为结点的平衡因子（BF） 平衡因子=结点左子树的高度-
树、森林与二叉树的转换
热门推荐
CSDN
12-30 14万+
树、森林与二叉树的转换 1、树转换为二叉树 由于二叉树是有序的，为了避免混淆，对于无序树，我们约定树中的每个结点的孩子结点按从左到右的顺序进行编号。 将树转换成二叉树的步骤是： （1）加线。就是在所有兄弟结点之间加一条连线； （2）抹线。就是对树中的每个结点，只保留他与第一个孩子结点之间的连线，删除它与其它孩子结点之间的连线； （3）旋转。就是以树的根结点为轴心，将整棵树顺时针旋转一定...
二叉树建立
Monster
03-20 3万+
结束二叉树输入：如何结束创建二叉树的输入那；把二叉树补全 前序（输入）：AB##C## 中序：#B#A#C# 后序：##B##CA 输出结果如下： 代码如下 #include<iostream> using namespace std; //定义节点 typedef struct node { struct node *left; struct node *...
二叉树各种类型汇总
上善若泪
06-26 8432
文章目录1 树类型1.1 二叉树1.2 完全二叉树1.3 满二叉树1.4 二叉搜索树（二叉排序树、二叉查找树）1.5 平衡二叉树1.6 红黑树1.6.1 红黑树概念1.6.2 红黑树和AVL树区别1.7 B树类型1.7.1 B树1.7.2 B-树1.7.3 B+树1.7.4 B*树 学习了树的结构类型后，主要对各种树类型进行汇总总结 1 树类型 树中的基本概念：https://jingzh.blog.csdn.net/article/details/107128291 树类型概述： 二叉树，完全二叉树，满二
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
二叉树 基础
03-08
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树...
将满二叉树转化为求和二叉树_二叉树_
09-30
在IT领域，特别是数据结构和算法的学习中，二叉树是一种重要的抽象数据类型。满二叉树是一种特殊的二叉树，其中每一层都是完全填充的，除了可能的最后一层，且最后一层的所有节点都尽可能地向左靠拢。而将满二叉树...
线索二叉树
04-10
通过前序序列创建线索二叉树 1:中序遍历 2:查找节点前驱后继 3:插入节点 4:删除节点 0:退出
二叉树建立遍历
01-03
二叉树是一种重要的数据结构，它由节点组成，每个节点有两个子节点，分别称为左子节点和右子节点。在计算机科学中，二叉树被广泛应用于搜索、排序、表达式解析等多种场景。本主题主要关注的是二叉树的建立以及它的...
二叉树代码
04-29
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树...
有值二叉树
04-15
根据给定的信息，“有值二叉树”这一概念在IT领域通常是指一种特殊的二叉树结构，其中每个节点都包含具体的数值或者数据信息。在计算机科学中，二叉树是一种非常重要的数据结构，广泛应用于算法设计、数据组织与管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值