二叉树

最新推荐文章于 2022-10-30 23:58:17 发布
最新推荐文章于 2022-10-30 23:58:17 发布
阅读量325 收藏 2
点赞数
分类专栏： java基础 数据结构 文章标签： 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41792000/article/details/111462443
版权

二叉树

今天我们来说一下二叉树，先提一点，hash里面的红黑树也是从二叉树演变而来的，这个我们以后再说，这就涉及到动态查找。

1.二叉树的几种形式

1.二叉树

2.满二叉树

一棵二叉树的结点要么是叶子结点，要么它有两个子结点（如果一个二叉树的层数为K，且结点总数是(2^k) -1，则它就是满二叉树。）
在这里插入图片描述

3.完全二叉树

若设二叉树的深度为k，除第 k 层外，其它各层 (1～k-1) 的结点数都达到最大个数，第k 层所有的结点都连续集中在最左边，这就是完全二叉树。就是结点树为n的完全二叉树的结构要和满二叉树前你个结点的结构要一样。
在这里插入图片描述

4.哈夫曼树

树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。

结合哈夫曼编码去理解：https://www.cnblogs.com/-citywall123/p/11297523.html

5.平衡二叉树

它或者是一颗空树，或它的左子树和右子树的深度之差(平衡因子)的绝对值不超过1，且它的左子树和右子树都是一颗平衡二叉树。

在这里插入图片描述

2.二叉树的性质

  1. 二叉树结点的层次：规定根节点的层次为0，则其他结点的层次再从双亲父母结点层次+1；

  2. 二叉树的深度: 树中所有结点的层次树的最大值+1；

  3. 结点的度：该结点拥有子结点的个数；

  4. 二叉树中第i层（i>=0）层上的结点数最多为2的i次方；

  5. 深度为h（h>=1）的二叉树最多有2的h次方减1。

3.二叉树的遍历

经过二叉树的遍历，可以得到而二叉树结点的不同线性序列，将非线性结构的二叉树变为线性序列，从而可以确定二叉树中某个结点再某种遍历序列的前驱和后继。

1.先根遍历（DLR）

  1. 递归法

    public void preRootTraverse(TreeNode root){
    if(root!=null){
        System.out.println(root.data);
        preRootTraverse(root.left);
        preRootTraverse(root.right);
    }
}

  2. 非递归法

    将递归法转换为为非递归法一般有两种，一种是直接转换法，不需要回溯，递归结果通过循环结构来代替，通过一些变量来保存中间结果，比如说双指针、斐波那契。还有一种就是间接转换法，需要回溯，可以利用队列、栈来保存中间结果。

    递归法虽然写起来很方便，结构简洁，不过在时间和空间的开销比较大，所以我们借助栈来报存中间结果。

    这里我们使用栈来保存右子树。过程如下：

    （1）创建一个栈对象，让根结点入栈。

    （2）当栈不为空的时候，将栈顶结点抛出栈并访问该结点。

    （3）对当前访问结点的非空左孩子结点相继依次的访问，并将当前访问该结点的非空右孩子结点压入栈中。

    （4）重复（2）、（3），直到栈为空。

    public void preRootTraverse(TreeNode root){ 
    if(root!=null){
     
        LinkStack stack  = new LinkStack;//构造栈
        stack.push(root);//根结点入栈
        while(!stack.isEmpty()){//判断栈是否为空
            TreeNode node = stack.pop();//抛出栈顶元素，并返回其值
            System.out.print(node.data);//访问上一步返回的结点
            while(node!=null){
                if(node.left!=null){//访问左孩子
                    System.out.print(node.left.data);//访问结点
                }
                if(noded.right!=null){//访问右孩子，如果非空就入栈，
                    stack.push(node.right);
                }
                node = node.right;//依次访问下一个左结点
            }
        }
    }

}

2.中根遍历（LDR）

  1. 递归法

    public void inRootTraverse(TreeNode root){
    if(root!=null){
        preRootTraverse(root.left);
        System.out.println(root.data);
        preRootTraverse(root.right);
   }
}

  2. 非递归

    （1）创建一个栈对象，将根结点入栈。

    （2）若栈非空，将栈顶元素的非空左孩子结点相继入栈。

    （3）栈顶结点出栈，并访问非空栈顶接地那的非空右孩子结点入栈。

    （4）重复（2）、（3）直到栈为空。

    public void inRootTraverse(TreeNode root){
    if(root!=null){
        LinkStack stack  = new LinkStack;//构造栈
        stack.push(root);//根结点入栈
        while(!stack.isEmpty()){//判断栈是否为空
            while(stack.peek()!=null){//将栈顶结点的左孩子结点相继入栈
                stack.push(((TreeNode)stack.peek()).left);
            }
            stack.pop();//空结点退栈
            if(!stack.isEmpty()){
                TreeNode node = stack.pop();//移除栈顶结点，并返回其值
                System.out.print(node.data);//访问结点
                stack.push(node.right);//结点的右孩子入栈
            }          
    }

}

3.后根遍历（RDL）

  1. 递归法

    public void postRootTraverse(TreeNode root){
    if(root!=null){
        preRootTraverse(root.left);
        preRootTraverse(root.right);
        System.out.println(root.data);
    }
}

  2. 非递归

     /** 非递归使用单栈实现二叉树后序遍历 */
    public static void iterativePostOrder(BinaryTreeNode root) {
        Stack<BinaryTreeNode> stack = new Stack<>();
        BinaryTreeNode node = root;
        // 访问根节点时判断其右子树是够被访问过
        BinaryTreeNode preNode = null;
        while (node != null || stack.size() > 0) {
            // 把当前节点的左侧节点全部入栈
            while (node != null) {
                stack.push(node);
                node = node.left;
            }
            if (stack.size() > 0) {
                BinaryTreeNode temp = stack.peek().right;
                // 一个根节点被访问的前提是：无右子树或右子树已被访问过
                if (temp == null || temp == preNode) {
                    node = stack.pop();
                    visit(node);
                    preNode = node;// 记录刚被访问过的节点
                    node = null;
                } else {
                    // 处理右子树
                    node = temp;
                }
            }
        }
    }

4.层次遍历

  1. 广度优先遍历（BFS）

在这里插入图片描述

（1）创建一个队列对象，根结点入栈；

（2）若队列为空，将队列首结点出堆，并访问该结点，再将该节点的非空左右孩子结点入队列。

（3）重复（2），直到队列为空。

public void levelTraverse(TreeNode root){
    if(root!=null){
        LinkQueue q  = new LinkQueue;//构造队列
        q.offer(root);//根结点入队列
        while(!q.isEmpty()){//判断队列是否为空
            TreeNode node = q.poll();//抛出队列首元素，并返回其值
            System.out.print(node.data);//访问上一步返回的结点
            while(node!=null){
                if(node.left!=null){//访问左孩子，如果非空就入队列，
                     q.offer(node.left);
                }
                if(noded.right!=null){//访问右孩子，如果非空就入队列，
                    q.offer(node.right);
                }
            }
        }
    }

}

  1. 深度优先遍历（DFS）

    就是前后中遍历

4.算法应用

1.二叉树上的查找算法

（1）若二叉树为空，则不存在这个节点，返回空值，否则，将根结点的值与x进行比较，若相等，返回该结点。

（2）若不相等，则在该结点的左子树中进行查找，若找到返回找到的结点。

（3）若在左子树中没有找到值为x的结点，就继续在右子树中进行查找，并返回查找的结点。

public TreeNode searchNode(TreeNode T,Object x){//运用的先根节点的递归查找
    if(T!=null){
        if(T.data.equals(x)){
            return T;
            else{
                TreeNode Lresult = searchNode(T.left,x);
                return lresult!=nuLL? lresult:searchNode(T.right,x);
            }
        }
    }
    return null;
}

2.二叉树中结点的个数

  1. 先根遍历的方法

    public int countNode(TreeNode T){
    int count = 0;
    if(T!=null){
        count++;
        count+=countNode(T.left);
        count+=countNode(T.right);
    }
    return count;
}

  2. 层次遍历的方法

    public int countNode(TreeNode root){
    int count = 0;
    if(root!=null){
        LinkQueue q  = new LinkQueue;//构造队列
        q.offer(root);//根结点入队列
        while(!q.isEmpty()){//判断队列是否为空
            TreeNode node = q.poll();//抛出队列首元素，并返回其值
            count++;
            while(node!=null){
                if(node.left!=null){//访问左孩子，如果非空就入队列，
                     q.offer(node.left);
                }
                if(noded.right!=null){//访问右孩子，如果非空就入队列，
                    q.offer(node.right);
                }
            }
        }
    }

}

  3. 递归法

    publiv int countNode(TreeNode T){
    if(T==null){
        return 0;
    }
    else{
        return countNode(T.left)+countNode(T.right)+1;
    }
}

3.二叉树的深度

  1. 递归法

    publiv int getDepth(TreeNode T){
    if(T==null){
        return 0;
    }
    else{
        int lDepth = getDepth(T.left);
        int rDepth = getDepth(T.right);
        return Math.max(lDepth,rDepth)+1;
    }
}

  2. 层次遍历（bfs）

    class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) return 0;
        int depth = 0;
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        while (!q.isEmpty()) {
            int size = q.size();
            for (int i = 0; i < size; i++) {
                TreeNode tmp = q.poll();
                if (tmp.left != null) {
                    q.add(tmp.left);
                }
                if (tmp.right != null) {
                    q.add(tmp.right);
                }
            }
            depth++;
        }
        return depth;
    }
}

4.判断二叉树是否相等

  1. 递归法

    public boolean isEqual(TreeNode T1,TreeNode T2){
    if(T1=null&&T2==null){
        return true;
    }else if(T1!=null&&T2!==null){
        return(T1.data.equals(T2.data)&&(isEqual(T1.left,T2.left))&&(isEqual(T1.right,T2.right2));
    }else
        return false;
}

5.二叉树的建立

  1. 由先根遍历序列和中根遍历序列建立一颗二叉树

    （1）先取先根遍历的第一个结点作为根结点；

    （2）在中根遍历序列汇总寻找根结点，确定根结点在中根遍历序列中的位置，假设为i（0<=i<+=count-1）,其中，count就是二叉树遍历序列中总结点的个数。

    （3）在中根遍历序列中确定：根结点前的i个结点构成坐姿输的中根遍历序列，根结点后的count-1-i个结点构成右子树的中根遍历序列；

    （4）在先根遍历序列中确定：根结点后i个结点序列构成左子树的先根遍历序列，剩下的count-i-1个结点序列构成右子树的先根遍历序列；

    （5）由（3）、（4）又确定了左右子树的先根和中根遍历序列，接下来可以用同上述的方法来确定左、右子树的根结点，以此递归就可建立唯一的一课二叉树。

//声明参数：preOrder是整棵树的先根遍历序列，inOrder是整棵树的中根遍历序列，preIndex是先根遍历序列在preOrder中开始的位置，inIndex是中根遍历序列在inIndex中开始的位置，count便是树中结点的总个数。
public BiTree(String preOrder,String inOrder,int preIndex,int inIndex,int count){
    if(count>0){
        char r = preOrder.charAt(preIndex);
        int i=0;
        for(;i<count;i++){
            if(r=inOrder.charAt(i+inIndex))
                break;
        }
        root = new TreeNode(r);
        root.left = new BiTree(preOrder,inOrder,preIndex+1,inIndex,i).root;
        root.right = new BiTree(preOrder,inOrder,preIndex+1+i,inIndex+1+i,count-1-i).root;
    }
}
whpark
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构篇——二叉树
CZC1999的博客
10-31 164
引入 在数据结构中，将现实生活中的树根抽象为根节点(Root)树叉抽象为结点(Node)，将叶子抽象为(Leaf)，将树枝抽象为边(Edge)，且一条边只用来连接两个结点，互为父子节点。 二叉树的性质 二叉树 树可以没有结点，这种情况下把树称为空树。 树的层次从根节点开始算，即根节点算第\(1\)层。【也有的教材规定根结点在第\(0\)层，这里全部以\(1\)层为准】 把结点...
11.13数据结构----树与森林
剑！
11-13 1359
以下是今天学习数据结构的小总结；总体来说还是不错的。 接着昨天的线索二叉树还没学完呢！ 1.回复一下知识点 线索化二叉树：二叉树的线索化指的是依照某种遍历次序使二叉树成为线索二叉树的过程。 2.线索二叉树的遍历 在线索二叉树中，由于有线索存在，在某些情况下可以方便地找到指定结点在某种遍历序列中的直接前驱或直接后继。此外，在线索二叉树上进行某种遍历比在一般的二叉树上进行这种遍历要容易得多，不
DFS中的概念——树边、回溯边、前向边、交叉边
weixin_42067873的博客
09-08 4500
根据在有向图G上进行深度优先遍历所产生的深度优先森林，可以把图中的边分为四类： 树边：（Tree edge） 后向边：又称 回溯边（Back edge） 前向边：（Forward edge） 交叉边：（Cross edge） 树边，前向边，后向边，横叉边，应该说，不是一个图本身有的概念，应该是图进行DFS时才有的概念。图进行DFS会得到一棵DFS树（森林），在这个树上 才有了这些概念。对图进行DFS，可以从任意的顶点开始，遍历的方式也是多样的，所以不同的遍历会得到不同的DFS树，进而产生不同的..
树的常考性质
weixin_63349841的博客
04-30 1241
1.结点总数=总度数+1 2.度为m的树和m叉树的区别 树的度——各结点度的最大值 m叉树——每个结点最多只能有m个孩子的树 树的度与m叉树 度为m的树 m叉树 任意结点的度小于等于m 任意结点的度小于等于m 至少有一个结点度等于m 允许所有结点的度都小于m 一定是非空树，至少有m+1个结点 可以是空树 3.度为m的树第i层至多有m^i-1个结点 m叉树第i层至多有m^i-1个结点 4.高度为h的m叉树至多有...
数据结构--树、森林
修心
01-31 975
树、森林   树的存储结构   树的存储方式有很多种，既可采用顺序结构，又可采用链式存储结构，但无论采用何种存储方式，都要求能唯一的反映树中各结点之间的逻辑关系。下面是常见的存储结构：   双亲表示法   这种存储方式采用一组连续空间来存储每个结点，同时在每个结点中增设一个伪指针，指示其双亲结点在数组中的位置。   双亲表示法的存储结构描述: #define MAX_TREE_SIZE 100 //树中最多结点数 typedef struct{ //树中的结点定义 ElemType
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
二叉树 基础
03-08
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树...
将满二叉树转化为求和二叉树_二叉树_
09-30
在IT领域，特别是数据结构和算法的学习中，二叉树是一种重要的抽象数据类型。满二叉树是一种特殊的二叉树，其中每一层都是完全填充的，除了可能的最后一层，且最后一层的所有节点都尽可能地向左靠拢。而将满二叉树...
平衡二叉树
03-03
平衡二叉树Java实现，平衡二叉树Java实现，平衡二叉树Java实现，平衡二叉树Java实现，
线索二叉树
04-10
通过前序序列创建线索二叉树 1:中序遍历 2:查找节点前驱后继 3:插入节点 4:删除节点 0:退出
二叉树建立遍历
01-03
二叉树是一种重要的数据结构，它由节点组成，每个节点有两个子节点，分别称为左子节点和右子节点。在计算机科学中，二叉树被广泛应用于搜索、排序、表达式解析等多种场景。本主题主要关注的是二叉树的建立以及它的...
二叉树代码
04-29
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树...
数据结构05森林的边序创建
m0_51427019的博客
05-12 217
森林的边序创建 文章目录queue.h的引入实现代码 queue.h的引入 #include<stdio.h> #include<malloc.h> #include<assert.h> #include<string.h> struct bintreenode; #define qelemtype bintreenode* typedef struct qnode { qelemtype data; struct qnode *next; }qn
数据结构1800关于树的代码精选（一）
最新发布
qq_48443025的博客
10-30 752
数据结构
数据结构树习题（二）
无知的我
11-12 2212
已知深度为h的二叉树采用顺序存储结构已存放于数组BT[1:2^h-1]中，请写一非递归算法产生该二叉树的二叉链表结构。设二叉链表中链结点的构造为(lchild,data,rchild)，根结点所在链结点的指针由T给出。 设计思想：采用队列结构，先建立根结点入队。当队列不空时循环执行以下步骤：队头结点出队，如果有左孩子，则建立左孩子结点并入队，如果有右孩子，则建立右孩子结点并入队。 代码：
数据结构实验之图论一:基于邻接矩阵的广度优先搜索遍历_数据结构题库
weixin_39774905的博客
11-22 995
一．填空题(共200空，每空1分)基础知识，易，数据物理结构1. 数据物理结构主要有两种：顺序存储 、链式存储 。基础知识，较易，广义表2.广义表A=(m,(a,b))的元素分别是 m 和 (a,b) 。基础知识，易，图3.图具体分为四类分别是： 有向图 、无向图 、 有向网 和 无向网 。基础知识，较易，单链表4.在单链表中，除了首元结点外，任一结点的存储位置由 其直...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值