算法通关村——树的算法

最新推荐文章于 2024-06-12 10:00:23 发布
最新推荐文章于 2024-06-12 10:00:23 发布
阅读量58 收藏
点赞数
分类专栏： 算法通关村 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52056811/article/details/135041357
版权

迭代实现二叉树的遍历

144.二叉树的前序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if(root == null) {
            return res;
        }
        //辅助栈
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        //
        TreeNode cur = root;

        while(!stack.isEmpty() || node != null) {
            //一路向左下处理
            while(node != null) {
                res.add(node.val);
                stack.push(node);
                node = node.left;
            }
            //当没有左孩子时，取出栈中的节点，向右孩子处理
            //下一次循环即为，处理右子树
            node = stack.pop();
            node = node.right;
        }
    }
}

94.二叉树的中序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if(root == null) {
            return res;
        }
        //辅助栈
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        //
        TreeNode node = root;
        //首次进入循环，会出现stack为空的情况
        while(!stack.isEmpty() || node != null) {
            //一路向左下，不访问
            while(node != null) {
                stack.push(node);
                node = node.left;
            }
			//核心
            //如果节点没有右子树（node = node.right,之后由第一个循环进行判断）
            //说明以该节点作为根节点的树，已经遍历结束
            //会继续回溯
            node = stack.pop();
            res.add(node.val);
            node = node.right;
        }
        return res;
    }
}

145.二叉树的后序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if(root == null) {
            return res;
        }
        //辅助栈
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        //
        TreeNode pre = root;
        while(!stack.isEmpty() || root != null) {
            while(root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            //当前没有左子树了，判断是处理右子树，还是处理当前节点
            //右子树已经遍历过的两种情况：
            //没有右子树
            //右子树刚刚被遍历
            if(root.right == null || pre == root.right) {
                //访问节点
                res.add(root.val);
                //记录上一个访问的节点
                pre = root;
                //这里有个大坑
                //每次遍历完左子树
                //如果不做置空操作
                //则会重新入栈左子树
                root = null;
            } else {
                //处理右子树
                //将当前节点入栈
                //root指向右子树根节点
                stack.push(root);
                root = root.right;
            }
        }
        return res;
    }
}

树的经典算法

100.相同的树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        //若树为空则相同
        if(p == null && q == null) {
            return true;
        }
        //若任意一个为空则不相同
        if(p == null || q == null) {
            return false;
        }
        //值不相同则不相同
        if(p.val != q.val) {
            return false;
        }

        //左右子树均相同
        return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
    }
}

101.对称树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root.left == null && root.right == null) return true;
        return isSymmetric1(root.left, root.right);

    }

    public boolean isSymmetric1(TreeNode q, TreeNode p) {
        //结构对称
        //均为空，则对称
        if(q == null && p == null) {
            return true;
        }
        //任一为空，则不对称
        if(q == null || p == null) {
            return false;
        }
        //数值对称
        //左孩子等于右孩子，则对称
        if(p.val != q.val) {
            return false;
        }

        return isSymmetric1(q.left, p.right) && isSymmetric1(q.right, p.left);
    }
}

617.合并树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if(root1 == null) {
            return root2;
        }
        if(root2 == null) {
            return root1;
        }
        TreeNode merged = new TreeNode(root1.val + root2.val);
        merged.left = mergeTrees(root1.left, root2.left);
        merged.right = mergeTrees(root1.right, root2.right);
        return merged;
    }
}

路径问题

257.二叉树的所有路径

递归算法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new ArrayList<String>();
        dfs(root, "", res);
        return res;
    }
    void dfs(TreeNode root, String path, List<String> res) {
        if(root == null) return;
        //叶节点
        if(root.left == null && root.right == null) {
            res.add(path + root.val);
            return;
        }
        //路径的扩展，通过传参的方式
        dfs(root.left, path + root.val + "->", res);
        dfs(root.right, path + root.val + "->", res);
    }
}

迭代算法

回溯算法的入门，后续补充

112.路径总和

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if(root == null) {
            return false;
        }
        //进入根节点后，若 sum == root.val则为真
        if(root.left == null && root.right == null) {
            return sum == root.val;
        }
        boolean left = hasPathSum(root.left, sum - root.val);
        boolean right = hasPathSum(root.right, sum - root.val);
        return left || right;
    }

}

226.翻转二叉树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null) {
            return null;
        }
        
        if(root.left != null || root.right != null) {
            TreeNode tmp = root.left;
            root.left = root.right;
            root.right = tmp;
        }

        invertTree(root.left);
        invertTree(root.right);
        return root;
    }
}

深度问题

104.最大深度

递归

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        //每层节点返回当前深度
        //还要有大小比较
        //应该要有一个参数来传递当前的深度
        return getMaxDepth(root, 1);
        
    }
    
    //depth为当前的深度
    public int getMaxDepth(TreeNode root, int depth) {
        //处理到空节点返回0
        if(root == null) {
            return 0;
        }
        //若处理到叶子节点，则返回当前深度
        if(root.left == null && root.right == null) {
            return depth;
        }
        //返回深度的最大值
        return getMax(getMaxDepth(root.left, depth + 1), getMaxDepth(root.right, depth + 1));
    }

    public int getMax(int a, int b) {
        return a > b ? a : b;
    }
}

还有更简洁的代码

public int maxDepth(TreeNode root) {
    if(root == null) {
        return 0;
    }
    int leftDepth = maxDepth(root.left);
    int rightDepth = maxDepth(root.right);
    return max(leftDepth, rightDepth) + 1;
}

迭代

本质是层次遍历，计算层数

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null) {
            return 0;
        }
        Deque<TreeNode> queue = new LinkedList<TreeNode>();
        queue.addLast(root);
        int ans = 0;
        while(!queue.isEmpty()) {
            //上一次循环中，获取的一层的节点数
            int size = queue.size();
            ans++;
            for(int i = 0; i < size; i++) {
                //出队
                TreeNode tmp = queue.pollFirst();
                //子节点入队
                if(tmp.left != null) {
                    queue.addLast(tmp.left);
                }
                
                if(tmp.right != null) {
                    queue.addLast(tmp.right);
                }
                
            }
        }
        return ans;
        
    }
}

110.判断平衡二叉树

我写了一段错误代码，分享出来

class Solution {
    public boolean isBalanced(TreeNode root) {
        //本质：左右子树最大深度之差是否小于1
        if(root == null) {
            return true;
        }
        int leftDepth = getMaxDepth(root.left);
        int rightDepth = getMaxDepth(root.right);
        int flag = Math.abs(leftDepth - rightDepth);
        return flag <= 1;
    }
    public int getMaxDepth(TreeNode root) {
        if(root == null) return 0;
        int leftDepth = getMaxDepth(root.left);
        int rightDepth = getMaxDepth(root.right);
        return Math.max(leftDepth, rightDepth) + 1;
    }
}

这段代码的逻辑问题在于，只判断了当前节点的左右子树的最大深度差是否小于等于1，但没有判断左右子树本身是否是平衡二叉树。

在判断平衡二叉树时，需要同时满足两个条件：

  1. 当前节点的左右子树高度差不超过1。
  2. 当前节点的左子树和右子树都是平衡二叉树。

以下是正确代码

class Solution {
    public boolean isBalanced(TreeNode root) {
        //本质：左右子树最大深度之差是否小于1，再判断左右子树也是平衡二叉树
        if(root == null) {
            return true;
        }
        int leftDepth = getMaxDepth(root.left);
        int rightDepth = getMaxDepth(root.right);
        int depthDiff  = Math.abs(leftDepth - rightDepth);
        if(depthDiff  > 1) return false;

        boolean leftBalanced = isBalanced(root.left);
        boolean rightBalanced = isBalanced(root.right);
        
        return leftBalanced && rightBalanced;
    }
    public int getMaxDepth(TreeNode root) {
        if(root == null) return 0;
        int leftDepth = getMaxDepth(root.left);
        int rightDepth = getMaxDepth(root.right);
        return Math.max(leftDepth, rightDepth) + 1;
    }
}

优化

上面的代码，在每个节点上都进行了重复的递归计算，可以通过对每个节点记录其高度的方式来避免重复计算。

class Solution {
    public boolean isBalanced(TreeNode root) {
        return checkHeight(root) != -1;
    }
    
    private int checkHeight(TreeNode root) {
        if (root == null) {
            return 0;
        }
        
        int leftHeight = checkHeight(root.left);
        if (leftHeight == -1) {
            return -1;
        }
        
        int rightHeight = checkHeight(root.right);
        if (rightHeight == -1) {
            return -1;
        }
        
        int heightDiff = Math.abs(leftHeight - rightHeight);
        if (heightDiff > 1) {
            return -1;
        }
        
        return Math.max(leftHeight, rightHeight) + 1;
    }
}

111.最小深度

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        if(root == null) {
            return 0;
        }
        if(root.left == null && root.right == null) {
            return 1;
        }

        int min_depth = Integer.MAX_VALUE;
        if(root.left != null) {
            min_depth = Math.min(minDepth(root.left), min_depth);
        }
        if(root.right != null) {
            min_depth = Math.min(minDepth(root.right), min_depth);
        }

        return min_depth + 1;
    }
}

共同祖先

236.最近公共组选

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    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 null;
        if(left == null) return right;
        if(right == null) return left;
        return root;//if(left != null && right != null)
    }
}
weixin_52056811
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
贪心算法——最小生成树Prim
09-07
了解学习
决策树——ID3算法
01-20
决策树——ID3算法1.信息熵2.信息增益3.西瓜数据集来构造决策树 用信息增益大小作为决策树属性选择划分的依据是ID3算法构造决策树的核心思想 1.信息熵 在讲信息增益之前就不得不提到信息熵，信息熵定义为： 其中： ...
算法通关村——树的深度遍历
moqi997752的博客
11-03 679
本文主要介绍了树的深度遍历，并且用递归和迭代两种不同的思路去给出树的前序遍历、中序遍历和后序遍历的代码
算法通关村——递归
marrymlj的博客
08-08 115
有些情况不一定是触底才开始反弹，而是达到某种要求就要停止，这样需要考虑的情况会比较多。解决这类问题最直接的方式就是枚举，将可能的情况列举一下，再逐步优化。一般是根据题目要求先将能写的写出来，之后再逐步补充，后面在题目里再看。只有列举清楚了才可能将终止条件写完整，确定终止条件对于递归至关重要。递归是我们算法进阶的基础，是必须要掌握的内容。将递推公式和终止条件组合起来，变成完整的方法。1.与树和二叉树相关的大部分问题。3.快速排序，归并排序相关的问题。2.二分查找相关的问题。5.所有动态规划的问题。
算法通关村 —— 树的层次遍历问题
Beyondevt的博客
09-18 1429
目录树的层次遍历问题1 层次遍历简介2 树的层次遍历2.1 二叉树普通遍历2.2 二叉树自底向上遍历2.3 二叉树锯齿形遍历2.4 N叉树的层次遍历3 处理每层元素的题目3.1 在每个树行中找最大值二叉树的层次遍历是一个比较简单的问题，层次遍历又叫广度优先，从根节点开始，先访问根节点下面一层全部元素，再访问之后的层次，类似金字塔一层层访问，基本过程如下：给定一个二叉树，将其按层遍历得到节点值。（逐层地，从左到右访问所有节点）例如给定的二叉树为： 做法比较容易，先将根节点放到队列中，访问完当前节点后就将其
算法通关村——轻松搞定两树相等问题
weixin_47474875的博客
08-09 133
判断两棵树是否相同
算法通关村——数组问题
qq_58073221的博客
10-29 80
要操作的数组中除了某个数字只出现了一次之外，其他数字都出现了两次，所以可以定义一个变量赋初始值为0，用这个变量与数组中每个数字做异或运算，并将这个变量值更新为那个运算结果，直到数组遍历完毕，最后得到的变量的值就是数组中只出现了一次的数字了。题目明确说其他元素都是出现两次，我们也可以利用这个操作，当要添加的元素key与集合中已存在的数重复时，不再进行添加操作，而是将集合中的key一起删掉，这样整个数组遍历完后，集合中就只剩下了那个只出现了一次的数字了。输出：[0,0,1,1,2,2]
《算法通关村——理解树的结构》
2301_79136518的博客
12-14 35
深度优先遍历又可分为前序遍历、中序遍历、后序遍历（前、中、后都是针对中间的那个节点的）通过树我们得到了前中后三种遍历下的不同结果，那么如何通关得到的结果来画出树呢？我们知道前序是先遍历到中间那个节点的，于是我们对前序和中序进行划分，可得。有关树的基本概念和一些性质，请自行了解，在这不做讲解。深度优先遍历：有节点就往下遍历，遇到叶子节点再返回。有两种常见的方式：深度优先遍历和广度优先遍历。现在我们再试着根据中序和后序来恢复二叉树。我们试一试用前序和中序来恢复二叉树。广度优先遍历：一层一层地遍历。
算法通关村——计算器问题
weixin_64658019的博客
10-26 47
【代码】算法通关村——计算机问题。
算法通关村——相交链表
qq_53248026的博客
10-19 78
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null。一个结点可以被多指向，但是只可有一个后继结点。如下图则就是错误的第一张图：c1被a2和b2同时指向是没关系的。但是第二张图：c1同时指向a5和b4就是错误的。
算法通关村——二分查找
weixin_52056811的博客
12-17 65
【代码】算法通关村——二分查找。
算法通关村——快速排序
marrymlj的博客
08-13 60
【代码】算法通关村——快速排序。
算法学习资料——算法.zip
07-24
算法学习资料
RRT算法路径规划——Matlab代码
08-05
采用RRT算法，进行两点间的避障路径规划。 包括随机树生长和路径生成两部分。 加入了生成gif的代码，可以形成gif用于更好的展示结果。
【算法图解】——狄克斯特拉算法
01-20
计算非加权图的最短路径——广度优先算法 计算加权图的最小权重——狄克斯特拉算法 **注意：**当图中存在负权重时，无法使用狄克斯特拉算法 实现算法 节点 狄克斯特拉算法 # ------------整个图的散列表（字典）-...
力扣LCP 08.剧情触发时间
最新发布
Pisasama的博客
06-12 398
【代码】力扣LCP 08.剧情触发时间。
牛客网刷题 | BC118 N个数之和
m0_64000959的博客
06-09 487
目前主要分为三个专栏，后续还会添加： 专栏如下： C语言刷题解析 C语言系列文章 我的成长经历感谢阅读！初来乍到，如有错误请指出，感谢！输入数字N，然后输入N个数，计算这N个数的和。第一行输入一个整数N(0≤N≤50)，第二行输入用空格分隔的N个整数。输出为一行，为第二行输入的“N个整数之和”的计算结果。使用数组的方式 先将用户输入的几个数字分别存起来定义一个变量将它数字的和加起来然后输出 代码 2 ： 输入n个数相加，应该想到循
day31||第八章 贪心算法 part01● 理论基础 ● 455.分发饼干 ● 376. 摆动序列 ● 53. 最大子序和
xburner01的博客
06-09 256
思路没问题，代码仔细想想吧。尽可能把大饼干给大胃口的人，先排序是关键。
LeetCode 算法：轮转数组c++
小金牛来了
06-09 675
LeetCode 算法：轮转数组c++
非对称算法学习研究——rsa
01-09
RSA是一种非对称加密算法，由三位科学家Rivest、Shamir和Adleman共同发明，在加密和数字签名领域发挥着重要作用。RSA算法基于数论中的两个重要难题：大整数分解和模幂运算。 RSA算法的核心概念是公钥和私钥。在加密过程中，首先需要生成一对密钥，其中一个是公钥，可以公开给其他人使用，而另一个是私钥，必须保密。通过公钥可以将信息进行加密，而只有使用私钥才能解密。 RSA算法的加密过程如下：选择两个大素数p和q，并计算它们的乘积n=p*q作为所需的大整数。再选择一个与(p-1)*(q-1)互质的正整数e作为公钥，其中1 < e < (p-1)*(q-1)。然后计算d，满足(d*e) mod ((p-1)*(q-1)) = 1，并将d作为私钥。公钥对应着(n, e)，私钥对应着(n, d)。 对于明文M，加密后得到密文C，加密过程为C = M^e mod n。解密过程为M = C^d mod n。由于大整数分解问题的复杂性，只有获得私钥才能成功解密，保护了通信的安全性。 RSA算法广泛应用于计算机网络和电子商务中，例如在网站上进行数据传输过程中，使用RSA加密算法保护数据的机密性和完整性，确保数据不被窃取或篡改。 需要注意的是，尽管RSA算法在安全性上相对较好，但其加解密过程消耗较大的计算资源，在处理大量数据时效率可能较低。因此，在实际应用中，常常将RSA与其他加密算法结合使用，以平衡安全性和效率的要求。 总之，RSA算法作为一种非对称加密算法，通过公钥和私钥的配对实现信息的加密和解密。它在数据安全领域的应用广泛，为保护通信和数据的安全做出了重要贡献。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值