二叉树问题

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

二叉树问题

1 模板

1.1 递归（先、中、后）

数据结构：

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

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

模板：

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

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

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

1.2 非递归

1.2.1 先序

思想：
访问完父节点需要访问左节点和右节点，因此利用栈来记录左节点和右节点（注意出入栈顺序）。

模板：

public static void preOrder(Node head) {
    System.out.print("Pre-order: ");
    if (head == null) {
        return;
    }

    Stack<Node> stack = new Stack<>();
    stack.push(head);
    while (!stack.isEmpty()) {
        head = stack.pop();

        System.out.print(head.val + " ");
        if (head.right != null) {
            stack.push(head.right);
        }

        if (head.left != null) {
            stack.push(head.left);
        }
    }

    System.out.println();
}

1.2.2 中序

思想：
访问完左节点需要通过父节点访问剩余节点，因此利用栈来记录父节点。

模板：

public static void inOrder1(Node head) {
    System.out.print("In-order: ");

    if (head == null) {
        return;
    }

    Stack<Node> stack = new Stack<>();

    while (head != null || !stack.isEmpty()) {
        if (head != null) {
            stack.push(head);
            head = head.left;
        } else {
            head = stack.pop();
            System.out.print(head.val + " ");
            head = head.right;
        }
    }
    System.out.println();
}

public static void inOrder2(Node head) {
    System.out.print("In-order: ");

    if (head == null) {
        return;
    }

    Stack<Node> stack = new Stack<>();

    while (head != null || !stack.isEmpty()) {
        while (head != null) {
            stack.push(head);
            head = head.left;
        }
        head = stack.pop();
        System.out.print(head.val + " ");
        head = head.right;
    }
    System.out.println();
}

1.2.3 后序

思想：

模板：

public static void posOrder1(Node head) {
    System.out.print("Pos-order: ");

    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().val + " ");
    }
    System.out.println();
}

public static void posOrder2(Node head) {
    System.out.print("Pos-order: ");
    if (head == null){
        return;
    }

    Stack<Node> stack = new Stack<>();
    Node popNode = head;
    Node peekNode = head;
    stack.push(head);

    while (!stack.isEmpty()){
        peekNode = stack.peek();

        if (peekNode.left != null && peekNode.left != popNode && peekNode.right != popNode){
            // 左孩子
            stack.push(peekNode.left);
        }else if (peekNode.right != null && peekNode.right != popNode){
            // 右孩子
            stack.push(peekNode.right);
        }else {
            System.out.print(stack.pop().val + " ");
            popNode = peekNode;
        }
    }
    System.out.println();
}

1.3 层序遍历

不记录层次

public static void levelOrder(Node head) {
    System.out.print("Level-order: ");
    if (head == null) {
        return;
    }

    Queue<Node> queue = new LinkedList<>();
    queue.add(head);

    while (!queue.isEmpty()) {
        head = queue.poll();
        System.out.print(head.val + " ");
        if (head.left != null) {
            queue.add(head.left);
        }
        if (head.right != null) {
            queue.add(head.right);
        }
    }
    System.out.println();
}

记录层次

public List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> lists = new LinkedList<>();
    if (root == null){
        return lists;
    }

    TreeNode last = root;
    TreeNode nLast = null;

    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);

    List<Integer> list = new LinkedList<>();

    while (!queue.isEmpty()){
        root = queue.poll();
        list.add(root.val);
        
        if (root.left != null){
            queue.offer(root.left);
            nLast = root.left;
        }
        
        if (root.right != null){
            queue.offer(root.right);
            nLast = root.right;
        }
        
        if (root == last){
            lists.add(list);
            list = new LinkedList<>();
            last = nLast;
        }
    }
    return lists;
}

1.4 Moris遍历

思想：
Moris遍历利用二叉树中的空指针实现遍历，空间复杂度O(1)，时间复杂度O(N)，提高时间复杂度的常数。

2 例题

2.1 LeetCode 98. 验证二叉搜索树

题目描述：
给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

  • 节点的左子树只包含小于当前节点的数。
  • 节点的右子树只包含大于当前节点的数。
  • 所有左子树和右子树自身必须也是二叉搜索树。

实现思路：
中序遍历（可用非递归），数列递增。

参考代码：

public boolean isValidBST(TreeNode root) {
    if(root == null){
        return true;
    }

    Stack<TreeNode> stack = new Stack();
    TreeNode pre = null;
    while(root != null || !stack.isEmpty()){
        while(root != null){
            stack.push(root);
            root = root.left;
        }
        root = stack.pop();
        if(pre != null && root.val <= pre.val){
            return false;
        }
        pre = root;
        root = root.right;
    }
    return true;
}

2.2 LeetCode 101. 对称二叉树

题目描述：
给定一个二叉树，检查它是否是镜像对称的。

实现思路：

  1. 递归，双指针遍历。
  2. 非递归，翻译递归。

参考代码：
递归，双指针遍历

public boolean isSymmetric(TreeNode root) {
    return check(root,root);
}

public boolean check(TreeNode p1,TreeNode p2){
    if(p1 == null && p2 == null){
        return true;
    }
    
    if(p1 == null || p2 == null){
        return false;
    }

    return p1.val == p2.val && check(p1.left, p2.right) && check(p1.right, p2.left);
}

非递归

public boolean isSymmetric(TreeNode root) {
    if(root == null){
        return true;
    }

    Stack<TreeNode> stack1 = new Stack();
    Stack<TreeNode> stack2 = new Stack();
    TreeNode p1 = root;
    TreeNode p2 = root;
    stack1.push(p1);
    stack2.push(p2);

    while(!stack1.isEmpty() && !stack2.isEmpty()){
        p1 = stack1.pop();
        p2 = stack2.pop();

        if(p1.val != p2.val){
            return false;
        }

        if((p1.left != null && p2.right == null) || (p1.left == null && p2.right != null)){
            return false;
        }
        if((p1.right != null && p2.left == null) || (p1.right == null && p2.left != null)){
            return false;
        }

        if(p1.left != null){
            stack1.push(p1.left);
        }
        if(p1.right != null){
            stack1.push(p1.right);
        }
        if(p2.right != null){
            stack2.push(p2.right);
        }
        if(p2.left != null){
            stack2.push(p2.left);
        }
    }
    return true;
}

2.3 LeetCode 108. 将有序数组转换为二叉搜索树

题目描述：
将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

实现思路：
中序遍历，且根节点每次选择中间位置。

参考代码：

public TreeNode sortedArrayToBST(int[] nums) {
    if(nums == null || nums.length == 0){
        return null;
    }
    return process(nums, 0, nums.length - 1);
}

public TreeNode process(int[] nums, int start, int end){
    int mid = start + (end - start) / 2;
    TreeNode root = new TreeNode(nums[mid]);

    if(start < mid){
        root.left = process(nums, start, mid - 1);
    }

    if(mid < end){
        root.right = process(nums, mid + 1, end);
    }

    return root;
}

2.4 LeetCode 103. 二叉树的锯齿形层次遍历

题目描述：
给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

实现思路：
层序遍历，用一个双端队列记录。

参考代码：

public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
    List<List<Integer>> lists = new LinkedList();
    if(root == null){
        return lists;
    }

    boolean lr = true;
    TreeNode last = root;
    TreeNode nLast = null;
    Queue<TreeNode> queue = new LinkedList();
    Deque<Integer> deque = new LinkedList();
    queue.add(root);

    while(!queue.isEmpty()){
        root = queue.poll();
        deque.addLast(root.val);

        if(root.left != null){
            queue.add(root.left);
            nLast = root.left;
        }

        if(root.right != null){
            queue.add(root.right);
            nLast = root.right;
        }

        if(root == last){
            addList(deque, lists, lr);
            lr = !lr;
            last = nLast;
        }
    }
    return lists;
}

public void addList(Deque<Integer> deque, List<List<Integer>> lists, boolean lr){
    List<Integer> list = new LinkedList();
    if(lr){
        while(!deque.isEmpty()){
            list.add(deque.pollFirst());
        }
    }else{
        while(!deque.isEmpty()){
            list.add(deque.pollLast());
        }
    }
    lists.add(list);
}

2.5 LeetCode 105. 从前序与中序遍历序列构造二叉树

题目描述：
根据一棵树的前序遍历与中序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

实现思路：
递归：根据先序第一个节点，拆分中序数组，然后根据偏移量拆分先序数组。
先序 [ 根节点, [左子树的前序遍历结果], [右子树的前序遍历结果] ]
中序 [ [左子树的中序遍历结果], 根节点, [右子树的中序遍历结果] ]

参考代码：

public TreeNode buildTree(int[] preorder, int[] inorder) {
    if(preorder == null || inorder == null || preorder.length == 0 || inorder.length == 0 || preorder.length != inorder.length){
        return null;
    }

    HashMap<Integer,Integer> map = new HashMap();
    for(int i = 0 ; i < inorder.length ; i++){
        map.put(inorder[i],i);
    }
    return process(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1, map);
}

public TreeNode process(int[] preorder, int s1, int e1, int[] inorder, int s2, int e2, HashMap<Integer,Integer> map){
    if(s1 > e1){
        return null;
    }

    TreeNode root = new TreeNode(preorder[s1]);
    int index = map.get(preorder[s1]);

    root.left = process(preorder, s1 + 1, s1 + (index - s2), inorder, s2, index - 1, map);
    root.right = process(preorder, s1 + (index - s2) + 1, e1, inorder, index + 1, e2, map);

    return root;
}

2.6 LeetCode 230. 二叉搜索树中第K小的元素

题目描述：
给定一个二叉搜索树，编写一个函数 kthSmallest 来查找其中第 k 个最小的元素。

说明：
你可以假设 k 总是有效的，1 ≤ k ≤ 二叉搜索树元素个数。

实现思路：
中序

参考代码：

public int kthSmallest(TreeNode root, int k) {
    if(root == null || k < 0){
        return -1;
    }
    Stack<TreeNode> stack = new Stack();
    while(root != null || !stack.isEmpty()){
        while(root != null){
            stack.add(root);
            root = root.left;
        }
        root = stack.pop();
        if(--k == 0){
            return root.val;
        }
        root = root.right;
    }
    return -1;
}

2.7 LeetCode 236. 二叉树的最近公共祖先

题目描述：
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

实现思路：
后序

参考代码：

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    if(root == null || root == p || root == q){
        return root;
    }
    TreeNode left = lowestCommonAncestor(root.left,p,q);
    TreeNode right = lowestCommonAncestor(root.right,p,q);
    
    if(left != null && right != null){
        return root;
    }

    return left != null ? left : right;
}

2.8 LeetCode 124. 二叉树中的最大路径和

题目描述：
给定一个非空二叉树，返回其最大路径和。

本题中，路径被定义为一条从树中任意节点出发，达到任意节点的序列。该路径至少包含一个节点，且不一定经过根节点。

实现思路：
后序遍历，根据左右字数返回的值（贡献值）计算当前树的最大路径值。

参考代码：

public int max = Integer.MIN_VALUE;

public int maxPathSum(TreeNode root) {
    process(root);
    return max;
}

public int process(TreeNode root){
    if(root == null){
        return 0;
    }

    int leftMax = Math.max(0, process(root.left));
    int rightMax = Math.max(0, process(root.right));

    max = Math.max(max, root.val + leftMax + rightMax);

    return root.val + Math.max(leftMax, rightMax);
}
zzypiper
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的前中后遍历
weixin_51746436的博客
11-22 537
一.什么是二叉树？ 二叉树是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。 二.二叉树的实现代码 public class Mytree { private Node root; public void add(int x) { Node a=new Node(); a.data=x; if(root==null) {
二叉树相关问题
qq_52188757的博客
11-08 307
要想是二叉树的最小高度,那该二叉树为完全二叉树啊,那么对应的高度为：log2(2000)下取整再加1等于11 棵二元树有67个结点,这些结点的度要么是0，要么是2。这棵二元树中度数为2的结点有？个。 答案是34，感觉它有问题 我来答 分享 举报 1个回答 #热议#购买OPPO Reno6可享受的服务权益有哪些？ 滴吊吟 2013-04-22·TA获得超过357个赞 关注 1+2+4+8+16+32+4 这是二元树从上到下的构成，最上面的肯定是2，而下面的都是0，2均分的，所...
二叉树常见问题
tyf4350158的博客
08-25 1484
二叉搜索树常见刷题
二叉树的经典问题
m0_69356256的博客
02-05 223
二叉树的经典问题
LeetCode二叉树问题全解析（上）
qq_59539549的博客
03-09 1494
一、前言 二叉树的定义：二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个节点最多只能有两棵子树，且有左右之分 在解决二叉树问题时，我们的利器就是“递归”，但是递归这种思想掌握起来常常让大家叫苦不迭，本篇文章将从易到难，深入浅出地讲解二叉树问题 对于二叉树，我们首先要了解几个最基本的公式： 1.若规定根节点的层数为1，则层数
LeetCode二叉树问题全解析（中）
qq_59539549的博客
03-12 1892
一、二叉树的修改与改造问题 1、翻转二叉树 给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。 这道题目大家第一次做可能会觉得它很简单，左换右，一直递归不就行了 但如果沉下心来思考这道问题的本质 我相信大家一定有所收获！ 之前我们介绍了各种遍历二叉树的方式，如果要翻转这颗二叉树 我们应该采取哪一种遍历方式呢？ 其实这道题采用前，中，后都可以 只要在遍历时交换左右节点即可 但是中序的时候有些麻烦 因为 我们左子树的节点已经完成了翻转而此时左右交换，中序遍历恰好需要到右子树.
python先序遍历二叉树问题
09-21
在实际应用中，先序遍历常用于复制或打印二叉树的结构，以及某些特定问题的求解。 在Python中，我们可以用递归的方式来实现先序遍历。以下是一个简单的Python代码示例，定义了一个`TreeNode`类来表示二叉树的节点，...
数据结构二叉树问题
02-03
很好的数据结构编程代码，二叉树实验报告。是C++编程的源代码
二叉树后序遍历相关问题
最新发布
03-25
二叉树后序遍历相关问题 题目描述 给定一个二叉树的前序遍历和中序遍历的序列，输出对应这个二叉树的后续遍历序列。 输入描述: 输入为一行。 两个字符串,分别表示二叉树的前序遍历和中序遍历结果,用空格分隔。保证...
常见的二叉树问题
weixin_48424501的博客
01-03 698
1.判定二叉树是否是完全二叉树 public boolean isCBT(TreeNode root){ if(root==null){ return true; } Queue<TreeNode> queue=new LinkedList<>(); queue.offer(root); boolean flag=false; while(!queue.isEmpty()){ int size=queue.size(); for(int i=0;i<size
二叉树
热门推荐
Richard_Cai
09-19 5万+
二叉树的优势       在实际使用时会根据链表和有序数组等数据结构的不同优势进行选择。有序数组的优势在于二分查找，链表的优势在于数据项的插入和数据项的删除。但是在有序数组中插入数据就会很慢，同样在链表中查找数据项效率就很低。综合以上情况，二叉树可以利用链表和有序数组的优势，同时可以合并有序数组和链表的优势，二叉树也是一种常用的数据结构。二叉树的构成      二叉树由节点（node）和边组成。节点
二叉树常见的问题和解决思路
weixin_39861267的博客
06-27 3154
二叉树的各种操作
二叉树的常见问题
子夜写字的地方
04-23 1692
据结构中的重要性就不言而喻了，这儿简单记录一下自己碰到的一些关于二叉树的常见操作。当然要明确解决这些问题的“根节点思路”了————递归递归recursion。 二叉树的最大深度与最小深度 最大深度是指二叉树根节点到该树叶子节点的最大路径长度。而最小深度自然就是其到叶子节点的最小路径长度了。 **主要思路：**采用二叉树递归的思想，自底向上，当到达叶子节点时，自然达到了“递归边界”，而叶子节点的子...
二叉树常见问题整理
yy254117440的博客
11-22 4645
做leetcode二叉树的题目做了不少，觉得有必要总结一下。因为题型多归多，但其实无非就是dfs和bfs，总结一些常见的解法，对于加深这两周算法的理解很有帮助。 在做dfs的时候，主要思路是可以从上到下也可以从下到上，也就是分析每一个子树的根节点，然后分析该子树的内部子树或者外部子树的根节点，以此得出递归关系，也即是分治的思想。同时，对于每个节点的处理尝试利用前序、后序、中序遍历三种方法。 做b
【数据结构】二叉树知识点详解
Money、坤的博客
05-20 3824
二叉树 一、概念 1. 1 定义 一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。 二叉树的特点： 每个结点最多有两棵子树，即二叉树不存在度大于 2 的结点。 二叉树的子树有左右之分，其子树的次序不能颠倒，因此二叉树是有序树。 如下图为一颗二叉树：1. 2 概念 节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A的为6； 树的度：一棵树中，最大的节点的度称为树的度； 如上图：树的度为6 叶子节点或终端节点：度为0的节点称
二叉树相关问题(3)
weixin_43910151的博客
12-20 108
1、 判断是否为二叉搜索树(BST) 2、 计算最大深度和
树型动态规划：求解加分二叉树问题
"这篇资料主要讨论了两种与树相关的动态规划问题：树型动态规划以及一个具体的加分二叉树问题。树型动态规划涉及到利用树的结构解决动态规划问题，而加分二叉树问题则是一个寻找最高加分二叉树的优化问题。" 首先，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值