左程云 Java 笔记--二叉树

已于 2022-04-19 16:17:30 修改
阅读量898 收藏 7
点赞数 3
分类专栏： 左程云笔记 文章标签： java
于 2022-04-18 22:18:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yiersano/article/details/124258762
版权

文章目录

遍历

在这里插入图片描述

先序

递归法

    public static void preOrderRecur(Node head){
        if (head == null){
            return;
        }
        System.out.println(head.value + " ");
        preOrderRecur(head.left);
        preOrderRecur(head.right);
    }

非递归

在这里插入图片描述

public static void preOrderRecur1(Node head){
        if (head == null){
            return;
        }
        Stack<Node> stack = new Stack<>();
        stack.add(head);
        while (!stack.isEmpty()){
            head = stack.pop();
            System.out.println(head.value + " ");
            if (head.right != null){
                stack.push(head.right);
            }
            if (head.left != null){
                stack.push(head.right);
            }
        }
        System.out.println();
}

中序

递归法

public static void inOrderRecur(Node head){
        if (head == null){
            return;
        }
        inOrderRecur(head.left);
        System.out.println(head.value + " ");
        inOrderRecur(head.right);
    }

非递归

在这里插入图片描述

public static void inOrderRecur1(Node head){
        if (head == null){
            return;
        }
        Stack<Node> stack = new Stack<>();
        while (! stack.isEmpty() || head != null){
            if (head != null){
                stack.push(head);
                head = head.left;
            }else {
                head = stack.pop();
                System.out.println(head.value + " ");
                head = head.right
            }
        }
        System.out.println();
    }

后序

递归法

public static void posOrderRecur(Node head){
        if (head == null){
            return;
        }
        posOrderRecur(head.left);
        posOrderRecur(head.right);
        System.out.println(head.value + " ");
    }

非递归

头左右（入栈是 头右左）
（入栈头左右 再放入收集栈，遍历收集栈就是后序遍历）
在这里插入图片描述
（入栈头左右 再放入收集栈，遍历收集栈就是后序遍历）

public static void posOrderRecur1(Node head){
        if (head == null){
            return;
        }
        Stack<Node> stack = new Stack<>();
        Stack<Node> stack1 = new Stack<>();
        stack.add(head);
        while (! stack.isEmpty()){
            head = stack.pop();
            stack1.push(head);
            if (head.left != null){
                stack.push(head.left);
            }
            if (head.right != null){
                stack.push(head.right);
            }
        }
        while (stack1 != null){
            System.out.println(stack1.pop().value + " ");
        }
        System.out.println();
    }

深度优先遍历 == 先序遍历

宽度优先遍历

用队列，先进先出
先放头结点，弹出就打印，再放左再放右

public static void wOrder(Node head){
        if (head == null){
            return;
        }
        Queue<Node> queue = new LinkedList<>();
        queue.add(head);
        while (queue != null){
            Node cur = queue.poll();
            System.out.println(cur.value + " ");
            if (cur.left != null){
                queue.add(cur.left);
            }
            if (cur.right != null){
                queue.add(cur.right);
            }
        }
    }

求一棵二叉树最大宽度

在这里插入图片描述

    public static int wmax(Node head){
        if (head == null){
            return 0;
        }
        Queue<Node> queue = new LinkedList<>();
        queue.add(head);
        HashMap<Node, Integer> map = new HashMap<>();
        map.put(head,1);
        int curLever = 1;
        int curLeverNodes = 0;
        int max = Integer.MIN_VALUE;
        while (queue != null){
            Node cur = queue.poll();
            int curNodeLevel = map.get(cur);
            if (curNodeLevel == curLever){
                curLeverNodes++;
            }else {
                max = Math.max(max,curLeverNodes);
                curLever++;
                curLeverNodes = 1;
            }
            System.out.println(cur.value + " ");
            if (cur.left != null){
                map.put(cur.left,curLever+1);
                queue.add(cur.left);
            }
            if (cur.right != null){
                map.put(cur.right,curLever+1);
                queue.add(cur.right);
            }
        }
        return max;
    }

二叉树的相关概念及其实现判断

如何判断一颗二叉树是否是搜索二叉树?

在这里插入图片描述
（每颗子树都是左树比右树小）

中序遍历，如果都是升序就是搜索二叉树

    public static boolean chackBST(Node head){
        int preValue = Integer.MIN_VALUE;
        if (head == null){
            return true;
        }
        boolean isLeftBST = chackBST(head.left);
        if (!isLeftBST){
            return false;
        }
        if (head.value <= preValue) {
            return false;
        } else {
            preValue = head.value;
        }
        return chackBST(head.right);
    }
    public static boolean checkBST2(Node head){
        int preValue = Integer.MIN_VALUE;
        if (head == null){
            return true;
        }
        Stack<Node> stack = new Stack<>();
        while (! stack.isEmpty() || head != null){
            if (head != null){
                stack.push(head);
                head = head.left;
            }else {
                head = stack.pop();
                if (head.value <= preValue){
                    return false;
                }else {
                    preValue = head.value;
                }
                head = head.right;
            }
        }
        return true;
    }

套路解法

在这里插入图片描述

    public static boolean checkBST3(Node head){
        return process1(head).isBST;
    }
    public static class ReturnData{
        public boolean isBST;
        public int max;
        public int min;

        public ReturnData(boolean isBST, int max, int min) {
            this.isBST = isBST;
            this.max = max;
            this.min = min;
        }
    }
    public static ReturnData process1(Node x){
        if (x == null){
            return  null;
        }
        ReturnData leftData = process1(x.left);
        ReturnData rightData = process1(x.right);
        int min = x.value;
        int max = x.value;
        if (leftData != null){
            min = Math.min(min,leftData.min);
            max = Math.max(max,leftData.max);
        }
        if (rightData != null){
            min = Math.min(min,rightData.min);
            max = Math.max(max,rightData.max);
        }

        boolean isBST = true;
        if (leftData != null && (!leftData.isBST || leftData.max >= x.value)){
            isBST = false;
        }
        if (rightData != null && (!rightData.isBST || rightData.min <= x.value)){
            isBST = false;
        }
        return new ReturnData(isBST,min,max);
    }

如何判断一颗二叉树是完全二叉树?

在这里插入图片描述

按宽度来遍历

  1. 有右无左 返回false
  2. 在1不违规的情况下，如果遇到了第一个左右不全的节点，则后面的都为叶节点。
    public static boolean isCBT(Node head){
        if (head == null){
            return true;
        }
        LinkedList<Node> queue = new LinkedList<>();
        boolean leaf = false;//是否遇到左右不双全的节点，无false，有就为ture
        Node l = null;
        Node r = null;
        queue.add(head);
        while (!queue.isEmpty()){
            head = queue.poll();
            l = head.left;
            r = head.right;
            if (//第一个是 不双全但还有子节点  第二个是 左无右有  直接false
                    (leaf && (l != null || r != null)) || (l == null && r != null)
            ){
                return false;
            }
            if (l != null){
               queue.add(l);
            }
            if (r != null){
                queue.add(r);
            }
            if (l == null || r == null){//如果不双全 leaf = true
                leaf = true;
            }
        }
        return true;
    }

如何判断一颗二叉树是否是满二叉树?

  • 最大深度 L 节点数 N 如果满足 n = 2^L -1 就是满二叉树

套路解法

    public static boolean isF(Node head){
        if (head == null){
            return true;
        }
        Info data = process3(head);
        return data.nodes == (1 << data.height -1);
    }
    public static class Info{
        public int nodes;
        public int height;

        public Info(int nodes, int height) {
            this.nodes = nodes;
            this.height = height;
        }
    }
    public static Info process3(Node x){
        if (x == null){
            return new Info(0,0);
        }
        Info leftData = process3(x.left);
        Info rightData = process3(x.right);

        int height = Math.max(leftData.height, rightData.height)+1;
        int nodes = leftData.nodes + rightData.nodes +1;

        return new Info(height,nodes);
    }

如何判断一颗二叉树是否是平衡二叉树? (二叉树题目 套路)

在这里插入图片描述

套路解法

public static boolean isBalanced(Node head){
        return process(head).isBalanced;
    }
    public static class ReturnType{
        public boolean isBalanced;
        public int height;
        public ReturnType(boolean isBalanced, int height) {
            this.isBalanced = isBalanced;
            this.height = height;
        }
    }
    public static ReturnType process(Node x){
        if (x == null){
            return new ReturnType(true,0);
        }

        ReturnType leftData = process(x.left);
        ReturnType rightData = process(x.right);

        int height = Math.max(leftData.height, rightData.height)+1;
        boolean isBalanced = leftData.isBalanced && rightData.isBalanced
                && Math.abs(leftData.height- rightData.height) < 2;
        return new ReturnType(isBalanced,height);
    }

*递归套路 =====》树型DP*

最低公共祖先

    public static Node lca(Node head, Node o1, Node o2){
        HashMap<Node,Node> fathermap = new HashMap<>();
        fathermap.put(head,head);
        process4(head,fathermap);
        HashSet<Node> set1 = new HashSet<>();
        Node cur = o1;
        while (cur != fathermap.get(cur)){
            set1.add(cur);
            cur = fathermap.get(cur);
        }
        set1.add(head);

        Node cur2 = o2;
        while (!set1.contains(cur2)){
            cur2 = fathermap.get(cur2);
        }
        return cur2;
    }
    public static void process4(Node head, HashMap<Node, Node> fathermap) {
        if (head == null){
            return;
        }
        fathermap.put(head.left,head);
        fathermap.put(head.right,head);
        process4(head.left, fathermap);
        process4(head.right, fathermap);
    }
  1. o1是o2 / o2是o1 的最低公共祖先
  2. o1o2不互为公共祖先（向上汇聚找到）
    public static Node lowca(Node head, Node o1, Node o2){
        if (head == null || head == o1 || head == o2){
            return head;
        }
        Node left = lowca(head.left, o1, o2);
        Node right = lowca(head.right, o1, o2);
        if (left != null && right != null){
            return head;
        }
        return left != null ? left : right;
    }

在二叉树中找到一个节点的后继节点

[题目]现在有 - -种新的二叉树节点类型如下:

public class Node{
	public int value;
	public Node left;
	public Node right;
	public Node parent;
	public Node(int val) {
		value = val ;
	}
}

该结构比普通二叉树节点结构多了一个指向父节点的parent指针。
假设有一棵Node类型的节点组成的二叉树，树中每个节点的parent指针都正确地指向自己的父节点，头节点的parent指向null。
只给一个在二叉树中的某个节点node，请实现返回node的后继节点的函数。
(在二叉树的中序遍历的序列中，node的 下一个节点叫作node的后继节点。)

  1. x有右树，后继是右树的最左边
  2. x无右树，向上找，是一个节点的左树时这个节点是x的后继
  3. 向上一直不是左节点，则为最右的节点，后继为null
   public static Node1 getSuccessorNode(Node1 node){
        if (node == null){
            return node;
        }
        if (node.right != null){
            return getLeftMost(node.right);
        }else { //无右子树
            Node1 parent = node.parent;
            while (parent != null && parent.left != node){
                node = node.parent;
                parent = node.parent;
            }
            return parent;
        }
    }
    public static Node1 getLeftMost(Node1 node) {
        if (node == null){
            return node;
        }
        if (node.left != null){
            node = node.left;
        }
        return node;
    }

二叉树的序列化和反序列化

就是内存里的一棵树如何变成字符串形式，又如何从字符串形式变成内存里的树
在这里插入图片描述

    public static String serialByPre(Node head){
        if (head == null){
            return "#_";
        }
        String res = head.value + "_";
        res += serialByPre(head.left);
        res += serialByPre(head.right);
        return res;
    }
    public static Node reconByPreString(String preStr){
        String[] values = preStr.split("_");
        Queue<String> queue = new LinkedList<>();
        for (int i = 0; i < values.length; i++) {
            queue.add(values[i]);
        }
        return reconPreOrder(queue);
    }

    public static Node reconPreOrder(Queue<String> queue) {
        String value = queue.poll();
        if (value.equals("#")){
            return null;
        }
        Node head = new Node(Integer.valueOf(value));
        head.left = reconPreOrder(queue);
        head.right = reconPreOrder(queue);
        return head;
    }

如何判断一颗二叉树是不是另一棵二叉树的子树?

折纸问题

在这里插入图片描述

   public static void printAllFolds(int N){
        printProcess(1,N,true);
    }
    public static void printProcess(int i, int N, boolean down){
        if (i > N){
            return;
        }
        printProcess(i+1,N,true);
        System.out.println(down ? "凹" : "凸");
        printProcess(i+1,N,false);
    }

总结

yiersano
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
后序遍历二叉树-Java 版本
04-26
在Java中，实现二叉树的后序遍历可以通过递归来完成。后序遍历的顺序是：首先递归地遍历左子树，然后递归地遍历右子树，最后访问根节点。 在这段代码中，Node类定义了二叉树的节点，BinaryTree类包含一个指向根节点...
左程云老师算法课笔记（一）
njh1147394013的博客
09-20 1707
左程云老师算法课笔记（一）
左程云算法笔记总结-基础提升篇
m0_63323097的博客
04-02 1439
1. 哈希函数的输入一般需要是无穷尽的，没有限制；输出可以有一定的范围，比如MD5加密后产生的字符串可以有2的32次方-1种，用十六进制表示需要16个字符。 2. 相同的输入对应相同的输出，不具有随机性
算法大神左程云耗尽5年心血分享程序员代码面试指南第2版文档(1)
2401_84418977的博客
04-20 2028
各位读者，由于本篇幅度过长，为了避免影响阅读体验，下面我就大概概括了整理了网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
左程云算法学习笔记
qq_45753992的博客
02-11 7343
左程云算法笔记学习简介认识复杂度，对数器，二分法与异或线段树（区间修改树）功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 学习简介 2021寒假学习算法，在B站看到了左程云的算法，看了一下还不错。 认识复杂度，对数器，二分法与异或
笔记 左程云算法基础
m0_58125693的博客
06-20 1652
归并排序比O(N^2)的排序好在哪：O(N^2)的排序每一轮的比较是独立的，一轮中有大量的比较，但只解决一个数。归并排序每一次的比较信息是往下传递的，变成了整体有序的部分继续去和其他部分merge，没有浪费比较行为。暴力求解：对每个i的左边都遍历一遍，O(n^2)深度改写mergesort思路：把问题变成——求右边有多少个数比i位置的数大，小和中就产生多少个i位置的数此问题中merge时左右组数值相等时，要先拷贝右侧数组中的数 题目-逆序对问题 相当于求右边有多少个数比i位置的数小..........
左程云算法课笔记（不再更新..）
qq_57752978的博客
06-16 1746
B站左程云算法课笔记
中序遍历二叉树-java版本
最新发布
04-26
在Java中，实现二叉树的中序遍历同样可以通过递归来完成。中序遍历的顺序是：首先递归地中序遍历左子树，然后访问根节点，最后递归地中序遍历右子树。 在这段代码中，Node类定义了二叉树的节点，BinaryTree类包含一...
左程云leetcode-algorithm-and-data-structure:算法+数据结构=程序
06-30
左程云leetcode 数据结构和算法学习笔记 一、简介 1. 2. 3. 4. 5. 6. 二、数据结构 1. 二维数组（Array2D） 位数组（Bit Set） 静态数组（Fixed Size Array） 有序表（Ordered Array） 2. 队列（Queues） （后进先出...
Java 算法设计-二叉树打印
10-09
二叉树
数据结构-二叉树 JAVA语言实现
10-16
在JAVA中，我们通常通过创建一个类来表示二叉树节点，这个类包含节点值、左子节点和右子节点的引用。例如： ```java public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int val) { ...
左程云leetcode-hjLearningNotes:hj学习笔记
06-30
左程云leetcode hjLearningNotes 第一部分：设计模式 & UML 简单工厂 工厂方法模式 抽象工厂模式 策略模式 责任链模式 命令模式 模板方法模式 适配器模式 代理模式 外观模式 组合模式 装饰模式 享元模式 桥接模式 Builder模式 状态模式 解释器模式 观察者模式 备忘录模式 迭代器模式 访问者模式 中介者模式 第二部分：JAVA 第三部分：Spring框架 第四部分：中间件 第五部分 链表 字符串 树 图 查找 《剑指Offer》 《程序员面试金典》 《LeetCode》 《程序员代码面试指南(左程云)》 第四部分 第六部分   *
判断一个节点是不是另一个的节点的子节点；
xiueer
07-21 1546
class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } }public class Test { public static void main(String[] args) { //测试用节点数组
左程云算法笔记（持续更新）
qq_29763213的博客
11-13 1127
第一讲：时间复杂度与简单排序算法
左程云算法笔记总结-基础篇
m0_63323097的博客
04-02 1723
O 即 O(f(n))常数操作的数量写出来，不要低阶项，只要最高项，并且不要最高项的系数除了储存题目条件外的空间占用，如果只用固定数量的储存空间就能解决问题，不随N变化，那就是常数级O(1)相同为0，不同为1，也可以理解为无进位相加。两数交换的另一种写法，但实际上这种方式没一般方法快，而且如果两个数的内存地址一样，会把他们抹成0
【笔记：左程云算法与数据结构】5.二叉树
qq_42102962的博客
11-29 307
【笔记：左程云算法与数据结构】5.二叉树
左程云老师算法课笔记（三）
njh1147394013的博客
10-07 520
算法笔记
左程云算法笔记（三）堆排序、桶排序、排序总结
qq_42949310的博客
06-09 848
左程云算法笔记：堆排序、桶排序、排序总结
左神算法笔记05:前缀树、贪心算法、N皇后问题
upset_poor的博客
11-20 1811
前缀树 何为前缀树？如何生成前缀树？ 例子： 一个字符串类型的数组arr1，另一个字符串类型的数组arr2。 arr2中有哪些字符，是arr1中出现的？请打印。 arr2中有哪些字符，是作为arr1中某个字符串前缀出现的？请打印。 arr2中有哪些字符，是作为arr1中某个字符串前缀出现的？请打印arr2中出现次数最大的前缀。 public class TrieTree { public static class TrieNode{ //表示添加前缀树的时候，当前节点到达过多少次
JAVA7-1 二叉树的层次遍历
11-11
以下是JAVA实现二叉树层次遍历的代码： ```java import java.util.LinkedList; import java.util.Queue; public class BinaryTree { private Node root; public BinaryTree() { root = null; } // 层次遍历...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值