左神算法4.二叉树及相关习题理解

最新推荐文章于 2023-02-22 18:18:51 发布
最新推荐文章于 2023-02-22 18:18:51 发布
阅读量365 收藏 1
点赞数
分类专栏： 左神算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43185543/article/details/104299924
版权

题目1：实现二叉树的先序、中序、后序遍历[递归方式和非递归方式]

在这里插入图片描述

1.1递归实现

public class BinaryTreeWithRecur {
    public static class Node{
        public int value;
        public Node left;
        public Node right;

        public Node(int value){
            this.value=value;
        }
    }

    //先序遍历
    public void preOrderRecur(Node head){
        if(head==null){
            return;
        }
        System.out.print(head.value+" ");
        preOrderRecur(head.left);
        preOrderRecur(head.right);
    }

    //中序遍历
    public void inOrderRecur(Node head){
        if(head==null){
            return;
        }
        inOrderRecur(head.left);
        System.out.print(head.value+" ");
        inOrderRecur(head.right);
    }

    //后序遍历
    public void postOrderRecur(Node head){
        if(head==null){
            return;
        }
        postOrderRecur(head.left);
        postOrderRecur(head.right);
        System.out.print(head.value+" ");
    }

    //测试
    public static void main(String[] args) {
        BinaryTreeWithRecur tree=new BinaryTreeWithRecur();
        Node root=new Node(1);
        Node node1=new Node(2);
        Node node2=new Node(3);
        Node node3=new Node(4);
        Node node4=new Node(5);
        Node node5=new Node(6);
        Node node6=new Node(7);

        root.left=node1;
        root.right=node2;
        node1.left=node3;
        node1.right=node4;
        node2.left=node5;
        node2.left=node6;

        System.out.println("前序遍历：");
        tree.preOrderRecur(root);
        System.out.println();
        System.out.println("中序遍历：");
        tree.inOrderRecur(root);
        System.out.println();
        System.out.println("后序遍历：");
        tree.postOrderRecur(root);
    }
}

运行结果：
在这里插入图片描述

1.2非递归实现

绝大多数可以用递归来解决的问题，其实都可以用另一种数据结构来解决，这种数据结构就是栈。因为递归和栈都有回溯的特性。
用栈结构以非递归的方式来模拟递归方式实现元素前序遍历，如下图所示：
在这里插入图片描述

//非递归实现前序遍历

//处理当前结点，有右孩子先压右孩子进栈，有左孩子再压左孩子进栈，
//那么这样弹出就会是先左，再右
    public static void preOrderUnRecur(Node head){
        if(head==null){
            return;
        }

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

    //非递归实现中序遍历
    /*
    当前节点不为空，当前节点入栈，当前节点向左
    当前节点为空,栈顶节点出栈打印，栈顶的节点向右
     */
    public static void inOrderUnRecur(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.print(head.value+" ");
                head=head.right;
            }
        }
        System.out.println();
    }

    //非递归实现后序遍历
	//先序中左右，先处理当前结点，然后改为先压左孩子，再压右孩子，
	//那么弹出的顺序就成为了右左【中右左】，利用一个栈即可变为左右中
     public static void postOrderUnRecur(Node head){
        if(head==null){
            return;
        }
        Stack<Node> stack1=new Stack<>();
        Stack<Node> stack2=new Stack<>();
        stack1.push(head);
        while(!stack1.isEmpty()){
            head=stack1.pop();
            stack2.push(head);
            if(head.left!=null){
                stack1.push(head.left);
            }
            if(head.right!=null){
                stack1.push(head.right);
            }
        }
        while(!stack2.isEmpty()){
            System.out.print(stack2.pop().value+" ");
        }
         System.out.println();
     }

题目2：在二叉树中找到一个节点的后继节点

【题目】 现在有一种新的二叉树节点类型如下：

public class Node { 
    public int value; 
    public Node left;
    public Node right;
    public Node parent;
    public Node(int data) { 
    	this.value = data; 
    }
}
  • 二叉树节点结构多了一个指向父节点的parent指针。假设有一棵Node类型的节点组成的二叉树，树中每个节点的parent指针都正确地指向自己的父节点，头节点的parent指向null。现在只给一个在二叉树中的某个节点 node，请实现返回node的后继节点的函数。在二叉树的中序遍历的序列中，node的下一个节点叫作node的后继节点，node的上一个节点叫做它的前驱节点。
技巧：
  • 1.当前节点有右子树，则找右子树中最左的节点即为当前节点的后继节点；
  • 2.当前节点没有右子树，则向上找到一个父节点，看当前节点是否位于该父节点的右子树的，那么这个父节点的父节点即为当前节点的后继节点 。
public class SuccessorNode {
    public static class Node{
        private int value;
        private Node left;
        private Node right;
        private Node parent;   // 新增：父节点指针

        public Node(int value){
            this.value = value;
        }
    }
    public static Node getSuccessorNode(Node node){
        if(node==null){
            return node;
        }
        // 如果该节点存在右子节点，后继节点是右子树中的最左边节点
        if(node.right!=null){
            return getLeftNodeMost(node.right);
        }else{
        // 如果当前节点没有右子树，向上查找当前节点属于哪个节点的左子树下面
        // 整棵树只有最后一个节点没有后继节点，会查找到根节点的父节点为null
            Node parent=node.parent;
            while(parent!=null&&parent.left!=node){
                node=parent;
                parent=node.parent;
            }
            return parent;
        }
    }

    public static Node getLeftNodeMost(Node node){
        if(node==null){
            return node;
        }
        while(node.left!=null){
            node=node.left;
        }
        return node;
    }
}

题目3：介绍二叉树的序列化和反序列化

序列化：记录二叉树结构。反序列化：还原二叉树结构。

  • “_”：用于分开节点中的值；
  • “#”：用于表示null空节点，用这些符号表示null节点把位置给占住，不然无法区分一些节点值都相等的情况。
以前序遍历为例，利用递归将二叉树序列化和反序列化：

public class SerializeAndReconstuct {
 
    public static class Node{
        private int val;
        private Node left;
        private Node right;
 
        public Node(int val){
            this.val = val;
        }
    }
 
    // 前序遍历  序列化二叉树
    public String serialByPre(Node head){
        if(head == null){
            return "#_";   // 空节点用#表示，不同节点值之间用_隔开
        }
        String res = head.val + "_";      // 中
        res += serialByPre(head.left);    // 左
        res += serialByPre(head.right);   // 右
        return res;
    }
 
    // 前序遍历  反序列化二叉树
    public Node reconByPreString(String str){
        String[] values = str.split("_");    // 将字符串分割成节点值组成的数组
        Queue<String> queue = new LinkedList<String>();
        for(String i : values){
        	// 将数组中的节点元素添加到队列中，也可以直接使用数组
            queue.add(i);   
        }
        return reconPreOrder(queue);
    }
 
    // 传入参数：队列 返回值：Node
    public Node reconPreOrder(Queue<String> queue){
        String val = queue.poll();
        if(val.equals("#")){
            return null;    // 如果值为#，则构建一个空节点
        }
        // 构建二叉树
        Node head = new Node(Integer.valueOf(val));
        head.left = reconPreOrder(queue);
        head.right = reconPreOrder(queue);
        return head;
    }
}
以前序遍历为例，利用层次将二叉树序列化和反序列化：
import java.util.LinkedList;
import java.util.Queue;
 
public class SerializeAndReconstructByLevel {
 
    public static class Node{
        private int val;
        private Node left;
        private Node right;
 
        public Node(int val){
            this.val = val;
        }
    }
 
    // 按层序列化
    public String serializeByLevel(Node head){
        if(head == null){
            return "#_";
        }
 
        String res = head.val + "_";
        Queue<Node> queue = new LinkedList<Node>();
        queue.offer(head);
        while(!queue.isEmpty()){
            // 中
            head = queue.poll();
            // 左
            if(head.left != null){
                res += head.left.val + "_";
                queue.offer(head.left);
            }else{
                res += "#_";
            }
            // 右
            if(head.right != null){
                res += head.right.val + "_";
                queue.offer(head.right);
            }else{
                res += "#_";
            }
        }
        return res;
    }
 
    // 按层反序列化
    public Node recornByLevelString(String levelStr){
        String[] values = levelStr.split("_");
        int index = 0;
        Node head = generateNodeByString(values[index++]);
        Queue<Node> queue = new LinkedList<Node>();
        if(head != null){
            queue.offer(head);           // 中
        }
        Node node = null;
        while(!queue.isEmpty()){
            node = queue.poll();
            node.left = generateNodeByString(values[index++]);
            node.right = generateNodeByString(values[index++]);
            if(node.left != null){
                queue.offer(node.left);   // 左
            }
            if(node.right != null){
                queue.offer(node.right);  // 右
            }
        }
        return head;
    }
 
    // 根据字符串构建一个节点
    public Node generateNodeByString(String str){
        if(str.equals("#")){
            return null;
        }
        return new Node(Integer.valueOf(str));
    }
}

题目4：判断一棵二叉树是否是平衡二叉树

平衡二叉树：对任何一棵树，其左右子树高度差不超过1
思路：只要以每个结点作为根节点的树都是平衡的，则整棵树就是平衡的
  • 1.左子树不平衡？
  • 2.右子树不平衡？
  • 3.都平衡，左树和右树的高度差超过1，则不是平衡树
  • 4.都平衡，左树和右树的高度差不超过1，则说明是平衡树
    递归实现返回信息：左树递归返回左树是否平衡和左树的高度，右树同样。

public class IsBalanceTree {
 
    public static class Node{
        private int val;
        private Node left;
        private Node right;
 
        public Node(int val){
            this.val = val;
        }
    }
 
    // 构建递归过程中的返回值结构
    public class ReturnData{
        public boolean isB;   // 是否平衡
        public int h;       // 高度
 
        public ReturnData(boolean B, int h){
            this.isB = B;
            this.h = h;
        }
    }
 
    // 主函数
    public boolean isBalance(Node head){
        return process(head).isB;
    }
 
    public ReturnData process(Node head){
        if(head == null){
            return new ReturnData(true, 0);
        }
 
        ReturnData leftData = process(head.left);   // 得到左子树是否平衡和高度信息
        if(leftData.isB == false){
            // 当前节点的左子树不平衡，整棵树都不平衡，高度信息没有用了，直接就-1
            return new ReturnData(false, -1);
        }
        ReturnData rightData = process(head.right);
        if(rightData.isB == false){
            // 当前节点的右子树不平衡，整棵树都不平衡，高度信息没有用了，直接就-1
            return new ReturnData(false, -1);
        }
 
        // 当前节点的左右子树都平衡，需要对比左右子树的高度差是否大于1
        if(Math.abs(rightData.h - leftData.h) > 1){
            return new ReturnData(false, -1);
        }
 
        // 左右子树都平衡，且高度差小于等于1，则此节点作为根节点的子树是平衡的
        // 高度则为左右子树中最高的高度+1
        return new ReturnData(true, Math.max(rightData.h, leftData.h) + 1);
    }
}

题目5：判断一棵树是否是搜索二叉树、判断一棵树是否是完全二叉树

5.1 搜索二叉树

没有重复结点（有重复的值可以放到同一个节点中，拉个链表），对任何一节点，左子树都比它小，右子树都比它大

判断方法：实际就是中序遍历的结果，如果是依次升序，就是搜索二叉树。只用在中序遍历打印节点的时机进行前一个数和当前数值大小的判断即可。
/*
	此代码在非递归中序遍历二叉树代码上改进
*/
public class IsBinarySearchTree {
 
    public static class Node{
        private int val;
        private Node left;
        private Node right;
 
        public Node(int val){
            this.val = val;
        }
    }
 
    // 判断一棵树是否是二叉搜索树
    public Boolean isBinarySearchTree(Node head){
        if(head == null){
            return true;   // 空树是二叉搜索树
        }
        // 这里将值设置为int类型的最小值，因为树里面第一个节点可能存的也是很小的值
        int pre = Integer.MIN_VALUE;  
        Stack<Node> stack = new Stack<Node>();
        
        while(!stack.isEmpty() || head != null){
            if(head != null){
                while (head != null){
                    stack.push(head.left);   // 压一绺左节点
                    head = head.left;
                }
            }else{
                // 当前节点为空，说明左边界压完了，则弹出节点（中），再处理右边界
                head = stack.pop();  // 中
                // 判断前一个数是否小于二叉树
                if(pre > head.val){
                    return false;
                }
                pre = head.val;
                head = head.right;   // 右
            }
        }
        return true;
    }
}

5.2 完全二叉树：从左往右对齐

判断方法：进行层序遍历每个结点：
  • 情况1：左右双全，则看下一个结点
  • 情况2：如果一个结点不是左右双全
    • 1 如果一个结点无左结点，有右节点，则一定不是完全二叉树
    • 2 如果一个结点有左结点，无右节点，则后面遇到的结点必须都是叶节点才能使完全二叉树，否则false
    • 3 如果一个结点无左结点，无右结点，则后面遇到的结点必须都是叶节点才能使完全二叉树，否则false
import java.util.LinkedList;
import java.util.Queue;

public class IsCompleteBT {

   public static class Node{
       private int val;
       private Node left;
       private Node right;

       public Node(int val){
           this.val = val;
       }
   }

   public Boolean isCompleteBT(Node head){
       if(head == null){
           return true;
       }

       Queue<Node> queue = new LinkedList<Node>();
       
       Boolean afterMustLeaf = false;   // 当前节点后面的节点都必须是子节点的开启标志
       
       Node left = null;
       Node right = null;
       queue.offer(head);
       while(!queue.isEmpty()){
           head = queue.poll();
           // 当开启所有子节点都必须为叶节点时，出现非叶节点，或者出现左子节点为空，右子节点不为空的情况直接返回false
           if(afterMustLeaf && (left != null || right != null)
            || 
            (left == null && right != null)){
               return false;
           }
           // 压入左子节点
           if(left != null){
               queue.offer(left);
           }
           // 压入右子节点
           if(right != null){
               queue.offer(right);
           }
           if(left==null || right==null){
               // 前面的节点都是左右双全，但是到这里少了右子节点【左子节点可能有也可能没有】，后序节点都必须为叶节点，开启标志
               afterMustLeaf = true;
           }
       }
       return true;
   }
}
hi168
关注
专栏目录
左神算法学习笔记基础篇（6）：二叉树
光脚小孩的博客
09-22 317
平衡二叉树的引入 当二叉排序树的左子树全为空（即有序表），则插入速度没有影响，但是查询速度明显降低。解决方案，使用平衡二叉树。 平衡二叉树（Self-Balancing Binary Search Tree）的定义 是一种特殊的二叉排序树,又被称为AVL树，可以保证查询效率较高 特点 它是一棵空树或者它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是平衡二叉树。 常用的实现方法 红黑树...
左神算法笔记（七）——二叉树
02-03 348
先序中序后序二叉树遍历 使用递归方法实现遍历,会发现代码非常的简单，这也可以看作是每种遍历方法的遍历整体的过程，其实完成的就是递归的操作，只是输出的时间不同。 public static class Node{ public int value; public Node left; public Node right; public Node(int data){ this.value...
左神算法笔记03:二叉树
upset_poor的博客
11-17 532
二叉树节点结构： class Node{ V value; Node left; Node right; } 用递归和非递归两种方式实现二叉树的前序、中序、后序遍历 如何直观的打印一颗二叉树 如何完成二叉树的宽度优先遍历（常见题目：求一颗二叉树的宽度） 用递归和非递归两种方式实现二叉树的前序、中序、后序遍历 递归方式 太简单了，无需赘述 非递归方式 前序遍历： 从栈中弹出一个节点cur 处理cur 先把cur的右孩子节点压入栈，再将cur的左孩子节点压入栈 周而复始 中序遍历： 定义一个栈 当
算法笔记——左神进阶（4）平衡搜索二叉树、累加和为定值最长子数组
现实 理想青年的博客
03-11 256
搜索二叉树 搜索二叉树：对于搜索二叉树的任何一个节点，左子树的值都比节点小，右子树的值都比他大。 TreeMap中，跟HashMap中一样可以提供key-value，同时会将key按照大小顺序排列。中间采用的就是搜索二叉树的知识。 具备平衡性的搜索二叉树： AVL树——平衡性最严格 任何一个节点的左子树和右子树高度差不大于1，复杂度还是O(logN)。导致调整非常频繁。 红黑树——平衡性要求不严格...
左神算法基础class4—题目8已知一棵完全二叉树，求其节点的个数
shi_xiao_xuan的博客
01-20 562
左神算法基础class4—题目8已知一棵完全二叉树，求其节点的个数1.题目：已知一棵完全二叉树，求其节点的个数。要求：时间复杂度低于O(N)，N为这棵树的节点个数2.分析3.核心代码（1）主函数（2）计算树的深度（3）计算节点个数4.完整代码5.复杂度分析 1.题目：已知一棵完全二叉树，求其节点的个数。要求：时间复杂度低于O(N)，N为这棵树的节点个数 2.分析 由于要求 时间复杂度小于O(N)，...
[C++算法入门]-二叉树打印练习题
09-26
文档中包含了一系列的练习题，涵盖了二叉树的构建、遍历和打印等方面。 通过完成这些练习，读者将能够掌握二叉树的基本概念和常用操作，并学会使用C++编写代码来解决与二叉树相关的算法问题。此外，文档还提供了...
Java二叉树算法实例.zip_java 二叉树_二叉树
09-22
6. **文件内容分析**：虽然压缩包中的"1.txt"和"www.pudn.com.txt"没有详细说明，但它们可能包含代码示例、解释性文本或练习题，帮助学习者理解二叉树的概念和操作。"1.txt"可能是一段Java代码，演示了如何实现...
二叉树的算法题备考.pdf
最新发布
08-25
在计算机考研 408 中，数据结构的应用题一直是重点和难点，而二叉树算法更是其中的关键部分。二叉树作为一种常见的数据结构，在算法设计和实际应用中都有着广泛的用途。本文将深入探讨二叉树算法在 408 数据结构应用...
二叉树练习题及答案.docx
12-05
通过这些练习题，我们可以深入理解二叉树的基本概念和性质，这对于计算机科学的学习，尤其是数据结构和算法分析非常重要。熟练掌握这些知识点将有助于解决更复杂的二叉树问题和设计高效的算法。
erchashu.rar_交换 二叉树 左右子树_交换左右子树
09-19
在IT领域，二叉树是一种基础且重要的数据结构，它被广泛应用于算法设计和数据处理。本主题聚焦于“交换二叉树的左右子树”的操作。二叉树的每个节点通常包含两个子节点，一个称为左子节点，另一个称为右子节点。交换...
左神算法大全
qq_51533426的博客
02-22 705
左神算法基础+中级+高级题目及源码
左神数据结构与算法笔记-----二叉树（一）
weixin_46236591的博客
02-25 537
二叉树 文章目录二叉树一、概念及结构二、二叉树三种遍历方法1、定义2、举例3、代码（递归方法）4.原理解析5.非递归方法三、二叉树的层序遍历四、总结 一、概念及结构 一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。 二叉树的特点： 1、每个结点最多有两棵子树，即二叉树不存在度大于2的结点。 2、二叉树的子树有左右之分，其子树的次序不能颠倒。 结构： class Node { V value; Node left; Node right;
左神算法笔记-5 二叉树
m0_51183169的博客
11-20 382
亡羊补牢，为时不晚；时不我待，舍我其谁！！ 链表遗留问题 相交与成环 成环意思是1-2-3-4-5-3-4-5-3-4-5-3……那么3就是入环节点 相交：两个链表有重合部分Y从相交的地方开始后面全都是共同部分，只能是Y不可能是X型因为单链表只有一个指针指向下一个所以不可能出现X相交 以后再分开的情况。 先判断是否成环如果有环返回入环节点： 法一：（用额外空间） 哈希表，从头遍历，检查哈希表中，表中无该节点则加入该节点，cur移动，表中出现某节点时，该节点为入环节点。 法二：（不用额外空间 快慢指针法（记
左神算法初级班五 笔记
The Shawshank Redemption
05-07 139
设计RandomPool结构 【题目】 设计一种结构，在该结构中有如下三个功能： insert(key)：将某个key加入到该结构，做到不重复加入。 delete(key)：将原本在结构中的某个key移除。 getRandom()： 等概率随机返回结构中的任何一个key。 【要求】 Insert、delete和getRandom方法的时间复杂度都是 O(1) 思路:要在O(1)的时间复杂度内...
动态规划的套路----左神
tangyuan_sibal的博客
06-19 1257
一、动态规划 首先动态规划不是一种数据结构，而是一种优化，它是一种用空间换时间的套路，它是递归的进阶版本。 二、动态规划的套路 使用动态规划套路的一个原则是能想出递归的解法。由递归来改成动态规划。 我们以这套例题来解释动态规划的套路 第一步： 写出递归的“试”法，看看如何尝试可以解决问题。 num：表示前几步已选择的值的和， 变量 id：在下标为 0 — id-1中的数中进行选择，变量 targ...
数据结构与算法面试题
BearDie的博客
09-04 311
class Test1 { public static void main(String[] args) { Node node1 = new Node(null,null,1);//根节点 Node node2 = new Node(null,null,1);//1层 Node node3 = new Node(nul...
Tree类的构造函数和成员函数
Self-den1al的博客
05-07 2746
定义一个Tree（树）类，有成员ages（树龄），不带参数的构造函数对ages初始化为1，成员函数grow(int years)对ages加上years，age()显示tree对象的ages的值。 ** Tree类声明如下：** class Tree { public: Tree();//构造函数 void grow(int years);//对数龄ages加上years void age();...
leetcode解题思路分析（十七）113 - 119题
ty的博客
03-22 175
路径总和2 给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。 本题和上题的区别在于需要记录所有路径，因此在递归函数中加上一个记录当前路径的数组，满足则输出 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; ...
刷面试题2个月了，终于拿到了梦寐以求大厂的offer了，数据结构和算法太TM重要了
如果频繁就私信一下呢
06-02 430
最近一个读者和我反馈，他坚持刷题2个月，终于去了他梦寐以求的大厂，薪资涨幅非常可观。并表示目前国内的大厂和一些独角兽，已经越来越效仿硅谷公司的做法，通过面试给定题编程，来考察数据结构和算法的扎实程度。 这种方式，即使对于工作多年的开发人员，没有经过训练，很容易就被挂了。从而与优秀的公司失之交臂。认识不少以前履历普通的，通过刷题改变了自己进入大厂的轨迹，从而走向更高的平台。刷题确实太重要了 因为大厂技术面试中，算法是其中必要的一个环节，业务问题可以好好总结总结，但算法就必须依靠牢固的基础和刷题量。 算法
二叉树理论与练习题解析
"二叉树课练空题" 这篇资料主要涵盖了二叉树的基础知识，包括定义、性质、形态以及遍历方法等。以下是详细的知识点解析：...通过上述练习题，可以加深对二叉树基本概念、性质和操作的理解，有助于准备相关考试或面试。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值