Leedcode算法专题训练（树）

最新推荐文章于 2022-01-07 00:08:04 发布
最新推荐文章于 2022-01-07 00:08:04 发布
阅读量291 收藏
点赞数
分类专栏： 数据结构-算法笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_39965800/article/details/109669295
版权

递归

一棵树要么是空树，要么有两个指针，每个指针指向一棵树。树是一种递归结构，很多树的问题可以使用递归来处理。

1. 树的高度

104. Maximum Depth of Binary Tree (Easy)

Leetcode / 力扣

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

2. 平衡树

110. Balanced Binary Tree (Easy)

Leetcode / 力扣

    3
   / \
  9  20
    /  \
   15   7

平衡树左右子树高度差都小于等于 1
 

class Solution {
    public boolean result=true;
    public boolean isBalanced(TreeNode root) {
        if(root==null)return true;
        if(Math.abs(depth(root.left)-depth(root.right))>1)return false;
        return isBalanced(root.left)&&isBalanced(root.right);
    }
    public int depth(TreeNode root){
        if(root==null)return 0;
        return Math.max(depth(root.left),depth(root.right))+1;
    }
}

3. 两节点的最长路径

543. Diameter of Binary Tree (Easy)

Leetcode / 力扣

Input:

         1
        / \
       2  3
      / \
     4   5

Return 3, which is the length of the path [4,2,1,3] or [5,2,1,3].
class Solution {
    private int max = 0;
    public int diameterOfBinaryTree(TreeNode root) {
        depth(root);
        return max;
    }
    
    private int depth(TreeNode root) {
        if (root == null) return 0;
        int leftDepth = depth(root.left);
        int rightDepth = depth(root.right);
        max = Math.max(max, leftDepth + rightDepth);
        return Math.max(leftDepth, rightDepth) + 1;
    }

}

4. 翻转树

226. Invert Binary Tree (Easy)

Leetcode / 力扣

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root==null)return null;
        TreeNode tmp=root.left;
        root.left=root.right;
        root.right=tmp;
        invertTree(root.left);
        invertTree(root.right);
        return root;
    }
}

5. 归并两棵树

617. Merge Two Binary Trees (Easy)

Leetcode / 力扣

Input:
       Tree 1                     Tree 2
          1                         2
         / \                       / \
        3   2                     1   3
       /                           \   \
      5                             4   7

Output:
         3
        / \
       4   5
      / \   \
     5   4   7
class Solution {
    public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
        if(t1==null&&t2==null)return null;
        if(t1==null)return t2;
        if(t2==null)return t1;
        TreeNode root =new TreeNode(t1.val+t2.val);
        root.left=mergeTrees(t1.left,t2.left);
        root.right=mergeTrees(t1.right,t2.right);
        return root;
    }
}

6. 判断路径和是否等于一个数

Leetcdoe : 112. Path Sum (Easy)

Leetcode / 力扣

Given the below binary tree and sum = 22,

              5
             / \
            4   8
           /   / \
          11  13  4
         /  \      \
        7    2      1

return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.
class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if(root==null)return false;
        if(root.left == null && root.right == null){
            return root.val == sum;
        }
        return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
    }
}

113. 路径总和 II

class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        List<List<Integer>> result=new ArrayList<>();
        dfs(root,sum,new ArrayList<>(),result);
        return result;
    }
    private void dfs(TreeNode root,int sum,List<Integer> list,List<List<Integer>>result){
        if(root==null){
            return;
        }
        list.add(root.val);
        if(root.left==null&&root.right==null&&sum==root.val){
            result.add(new ArrayList(list));
        }
        dfs(root.left,sum-root.val,list,result);
        dfs(root.right,sum-root.val,list,result);
        list.remove(list.size() - 1);
    }
}
}

7. 统计路径和等于一个数的路径数量

437. Path Sum III (Easy)

Leetcode / 力扣

java 双重递归 思路：首先先序递归遍历每个节点，再以每个节点作为起始点递归寻找满足条件的路径。

class Solution {
    public int pathSum(TreeNode root, int sum) {
        if(root==null)return 0;
        int result=countPath(root,sum);
        int a=pathSum(root.left,sum);
        int b=pathSum(root.right,sum);
        return result+a+b;
    }
    public int countPath(TreeNode root,int sum){
        if(root==null){
            return 0;
        }
        sum=sum-root.val;
        int result=sum==0?1:0;
        return result+countPath(root.left,sum)+countPath(root.right,sum);
    }
}

8. 子树

572. Subtree of Another Tree (Easy)

Leetcode / 力扣

class Solution {
    public boolean isSubtree(TreeNode s, TreeNode t) {
    if (s == null) return false;
    return isSubtreeWithRoot(s, t) || isSubtree(s.left, t) || isSubtree(s.right, t);
}

    private boolean isSubtreeWithRoot(TreeNode s, TreeNode t) {
         if(t==null&&s==null)return true;
        if(t==null||s==null)return false;
        if(t.val != s.val)return false;
        return isSubtreeWithRoot(s.left, t.left) && isSubtreeWithRoot(s.right, t.right);
    }
}

9. 树的对称

101. Symmetric Tree (Easy)

Leetcode / 力扣

    1
   / \
  2   2
 / \ / \
3  4 4  3
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root==null)return true;
        return isSymmetrictree(root.left,root.right);
    }

     private boolean isSymmetrictree(TreeNode left,TreeNode right){
        if(left==null&&right==null)return true;
        if(left==null||right==null)return false;
        if(left.val!=right.val)return false;
        return isSymmetrictree(left.left,right.right)&&isSymmetrictree(left.right,right.left);
    }
}

10. 最小路径

111. Minimum Depth of Binary Tree (Easy)

Leetcode / 力扣

树的根节点到叶子节点的最小路径长度

public int minDepth(TreeNode root) {
    if (root == null) return 0;
    int left = minDepth(root.left);
    int right = minDepth(root.right);
    if (left == 0 || right == 0) return left + right + 1;
    return Math.min(left, right) + 1;
}

11. 统计左叶子节点的和

404. Sum of Left Leaves (Easy)

Leetcode / 力扣

解题思路
1、终止条件,root == null时，返回0;
2、如果当前节点是左节点，并且无子节点，累加对应节点的val值;
3、继续搜索左右子树，直到root == null，即最后一个节点。

class Solution {
    private int res=0;
    public int sumOfLeftLeaves(TreeNode root) {
        if(root==null){
            return 0;
        }
        if(root.left!=null&&root.left.left==null&&root.left.right==null){
            res+=root.left.val;
        }
        sumOfLeftLeaves(root.left);
        sumOfLeftLeaves(root.right);
        return res;

    }
}

12. 相同节点值的最大路径长度

687. Longest Univalue Path (Easy)

Leetcode / 力扣

             1
            / \
           4   5
          / \   \
         4   4   5

Output : 2
class Solution {
    int ans;
    public int longestUnivaluePath(TreeNode root) {
        ans = 0;
        longestPath(root);
        return ans;
    }
    //递归函数功能：搜寻以node为起点的最长同值路径:要么是以node为起点的左子树，要么是以node为起点的右子树
    public int longestPath(TreeNode node) {
        if (node == null) return 0;
        int maxLorRres=0;
        int left = longestPath(node.left); //node左子树的最长同值路径
        int right = longestPath(node.right);//node右子树的最长同值路径
        //这种情况对于寻找最长同值路径长有帮助，对于搜索以root为路径起始点的最长路径没有帮助
        if (node.left != null && node.left.val == node.val&&node.right != null && node.right.val == node.val) {
            ans=Math.max(ans, left + right+2);
        }
        //从左右子树中选择最长的同值路径
        if(node.left!=null&&node.left.val == node.val){
            maxLorRres=left+1;
        }
        if(node.right!=null&&node.right.val==node.val){
            maxLorRres=Math.max(maxLorRres,right+1);
        }
        //从ans与maxLorRres中更新最大值
        ans=Math.max(ans,maxLorRres);
        return maxLorRres; //所以你能知道为什么返回这个值了吗？
    }

}
private int path = 0;

public int longestUnivaluePath(TreeNode root) {
    dfs(root);
    return path;
}

private int dfs(TreeNode root){
    if (root == null) return 0;
    int left = dfs(root.left);
    int right = dfs(root.right);
    int leftPath = root.left != null && root.left.val == root.val ? left + 1 : 0;
    int rightPath = root.right != null && root.right.val == root.val ? right + 1 : 0;
    path = Math.max(path, leftPath + rightPath);
    return Math.max(leftPath, rightPath);
}

13. 间隔遍历

337. House Robber III (Medium)

Leetcode / 力扣

     3
    / \
   2   3
    \   \
     3   1
Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.
class Solution {
    public int rob(TreeNode root) {
        if(root==null)return 0;
        int val1=root.val;
        if(root.left!=null)val1+=rob(root.left.left)+rob(root.left.right);
        if(root.right!=null)val1+=rob(root.right.left) + rob(root.right.right);
        int val2 = rob(root.left) + rob(root.right);
        return Math.max(val1, val2);
    }
}

14. 找出二叉树中第二小的节点

671. Second Minimum Node In a Binary Tree (Easy)

Leetcode / 力扣

Input:
   2
  / \
 2   5
    / \
    5  7

Output: 5
class Solution {
    public int findSecondMinimumValue(TreeNode root) {
     return traversal(root,root.val);
    }
    
    private int traversal(TreeNode root,int value){
        if(root == null){
            return -1;
        }
        if(root.val > value){
            return root.val;
        }
        // 寻找左右子节点中，第一个大于自己的节点
        int l = traversal(root.left,value);
        int r = traversal(root.right,value);

        // 存在两个子节点
        if(l>=0 && r>=0){
            return Math.min(l,r);
        }
        //　存在0个子节点
        return Math.max(l,r);
    }
  
}

层次遍历

使用 BFS 进行层次遍历。不需要使用两个队列来分别存储当前层的节点和下一层的节点，因为在开始遍历一层的节点时，当前队列中的节点数就是当前层的节点数，只要控制遍历这么多节点数，就能保证这次遍历的都是当前层的节点。

1. 一棵树每层节点的平均数

637. Average of Levels in Binary Tree (Easy)

Leetcode / 力扣

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> result=new ArrayList<>();
        if(root==null)return result;
        Queue<TreeNode>queue=new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            double sum=0;
            int length=queue.size();
            for(int i=queue.size();i>0;i--){
                TreeNode temp=queue.poll();
                sum+=temp.val;
                if(temp.left!=null)queue.add(temp.left);
                if(temp.right!=null)queue.add(temp.right);
            }
            result.add(sum/length);
        }
        return result;
    }
}

2. 得到左下角的节点

513. Find Bottom Left Tree Value (Easy)

Leetcode / 力扣

Input:

        1
       / \
      2   3
     /   / \
    4   5   6
       /
      7

Output:
7
class Solution {
    public int findBottomLeftValue(TreeNode root) {
        if(root==null)return 0;
        Queue<TreeNode> queue=new LinkedList<>();
        queue.add(root);
        int result=0;
        while(!queue.isEmpty()){
            TreeNode temp=queue.poll();
            result=temp.val;
            if (temp.right != null) queue.add(temp.right);
            if (temp.left != null) queue.add(temp.left);
        }
        return result;
    }
}

前中后序遍历

    1
   / \
  2   3
 / \   \
4   5   6
  • 层次遍历顺序：[1 2 3 4 5 6]
  • 前序遍历顺序：[1 2 4 5 3 6]
  • 中序遍历顺序：[4 2 5 1 3 6]
  • 后序遍历顺序：[4 5 2 6 3 1]

层次遍历使用 BFS 实现，利用的就是 BFS 一层一层遍历的特性；而前序、中序、后序遍历利用了 DFS 实现。

前序、中序、后序遍只是在对节点访问的顺序有一点不同，其它都相同。

① 前序

void dfs(TreeNode root) {
    visit(root);
    dfs(root.left);
    dfs(root.right);
}

② 中序

void dfs(TreeNode root) {
    dfs(root.left);
    visit(root);
    dfs(root.right);
}

③ 后序

void dfs(TreeNode root) {
    dfs(root.left);
    dfs(root.right);
    visit(root);
}

1. 非递归实现二叉树的前序遍历

144. Binary Tree Preorder Traversal (Medium)

Leetcode / 力扣

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list=new ArrayList<>();
        Stack<TreeNode> stack=new Stack<>();
        while(root!=null||(!stack.empty())){
            if(root!=null){
                list.add(root.val);//步骤一，取根节点的值
                stack.push(root);//把根节点放入栈中
                root=root.left;//步骤二，遍历左子树
            }
            else{
                TreeNode tem=stack.pop();
                root=tem.right;//步骤三，遍历右子树
            }
        }
        return list;
    }
}

2. 非递归实现二叉树的中序遍历

94. Binary Tree Inorder Traversal (Medium)

Leetcode / 力扣

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list=new ArrayList<>();
        Stack<TreeNode> stack=new Stack<>();
        while(root!=null||(!stack.empty())){
            if(root!=null){
                stack.push(root);//把根节点放入栈中
                root=root.left;//步骤一，遍历左子树
            }
            else{
                TreeNode tem=stack.pop();
                list.add(tem.val);//步骤二，取根结点的值
                root=tem.right;//步骤三，遍历右子树
            }
        }
        return list;
    }
}

3. 非递归实现二叉树的后序遍历

145. Binary Tree Postorder Traversal (Medium)

Leetcode / 力扣

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list=new ArrayList<>();
        Stack<TreeNode> stack=new Stack<>();
        while(root!=null||(!stack.empty())){
            if(root!=null){
             stack.push(root);//把根节点放入栈中
             list.add(0,root.val);//步骤一，在index=0处插入根结点的值
             root=root.right;//步骤二，遍历右子树
            }
            else{
                TreeNode tem=stack.pop();
                root=tem.left;//步骤三，遍历左子树
            }
        }
        return list;
    }
}

BST

二叉查找树（BST）：根节点大于等于左子树所有节点，小于等于右子树所有节点。

二叉查找树中序遍历有序。

1. 修剪二叉查找树

669. Trim a Binary Search Tree (Easy)

Leetcode / 力扣

class Solution {
    public TreeNode trimBST(TreeNode root, int low, int high) {
        if(root==null)return root;
        if(root.val>high)return trimBST(root.left,low,high);
        if(root.val<low)return trimBST(root.right,low,high);

        root.left=trimBST(root.left,low,high);
        root.right=trimBST(root.right,low,high);
        return root;
    }
}

2. 寻找二叉查找树的第 k 个元素

230. Kth Smallest Element in a BST (Medium)

Leetcode / 力扣

中序遍历解法：

class Solution {
    private int val;
    private int cnt=0;
    public int kthSmallest(TreeNode root, int k) {
        inOrder(root,k);
        return val;
    }

    private void inOrder(TreeNode node,int k){
        if(node==null)return;
        inOrder(node.left,k);
        cnt++;
        if(cnt==k){
          val=node.val;
          return;  
        }
        inOrder(node.right,k);

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

            root=root.right;
        }
    }
}

3. 把二叉查找树每个节点的值都加上比它大的节点的值

Convert BST to Greater Tree (Easy)

Leetcode / 力扣

Input: The root of a Binary Search Tree like this:

              5
            /   \
           2     13

Output: The root of a Greater Tree like this:

             18
            /   \
          20     13
class Solution {
    int sum=0;
    public TreeNode convertBST(TreeNode root) {
        if(root==null)return null;
        convertBST(root.right);
        sum+=root.val;
        root.val=sum;
        convertBST(root.left);
        return root;
    }
}

4. 二叉查找树的最近公共祖先

235. Lowest Common Ancestor of a Binary Search Tree (Easy)

Leetcode / 力扣

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root==null)return null;
        if(root.val>p.val&&root.val>q.val)return lowestCommonAncestor(root.left,p,q);
        else if(root.val<p.val&&root.val<q.val)return lowestCommonAncestor(root.right,p,q);
        return root;
    }
}

5. 二叉树的最近公共祖先

236. Lowest Common Ancestor of a Binary Tree (Medium)

Leetcode / 力扣

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 root;
        else if(left!=null&&right==null)return left;
        else return right;
    }
}

6. 从有序数组中构造二叉查找树

108. Convert Sorted Array to Binary Search Tree (Easy)

Leetcode / 力扣

class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        return helper(nums,0,nums.length-1);
    }

    public TreeNode helper(int[] nums,int lo,int hi){
        if(lo>hi){
            return null;
        }
        int mid=lo+(hi-lo)/2;
        TreeNode root=new TreeNode(nums[mid]);
        root.left=helper(nums,lo,mid-1);
        root.right=helper(nums,mid+1,hi);
        return root;
    }
}

7. 根据有序链表构造平衡的二叉查找树

109. Convert Sorted List to Binary Search Tree (Medium)

Leetcode / 力扣

class Solution {
    public TreeNode sortedListToBST(ListNode head) {
        if(head==null)return null;
        if(head.next==null)return new TreeNode(head.val);
        ListNode pre=null,fast=head,slow=head;
        while(fast!=null&&fast.next!=null){
            pre=slow;
            slow=slow.next;
            fast=fast.next.next;
        }
        pre.next=null;
        TreeNode root=new TreeNode(slow.val);
        root.left=sortedListToBST(head);
        root.right=sortedListToBST(slow.next);
        return root; 
    }
}

8. 在二叉查找树中寻找两个节点，使它们的和为一个给定值

653. Two Sum IV - Input is a BST (Easy)

Leetcode / 力扣

public class Solution {
    public boolean findTarget(TreeNode root, int k) {
        Set < Integer > set = new HashSet();
        return find(root, k, set);
    }
    public boolean find(TreeNode root, int k, Set < Integer > set) {
        if (root == null)
            return false;
        if (set.contains(k - root.val))
            return true;
        set.add(root.val);
        return find(root.left, k, set) || find(root.right, k, set);
    }
}

9. 在二叉查找树中查找两个节点之差的最小绝对值

这题的难点在于思考前向节点如何表示，还有BST的特性不难

530. Minimum Absolute Difference in BST (Easy)

Leetcode / 力扣

class Solution {
    int abs_min=Integer.MAX_VALUE;
    TreeNode pre;
    public int getMinimumDifference(TreeNode root) {
        if(root==null)return 0;
        inOrder(root);
        return abs_min;
    }

    private void inOrder(TreeNode node){
        if(node==null)return;
        inOrder(node.left);
        if(pre!=null) abs_min=Math.min(abs_min,node.val-pre.val);
        pre=node;
        inOrder(node.right);
    }
}

10. 寻找二叉查找树中出现次数最多的值

501. Find Mode in Binary Search Tree (Easy)

Leetcode / 力扣

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int preVal = 0, curTimes = 0, maxTimes = 0;
    ArrayList<Integer> list = new ArrayList<Integer>();
    public int[] findMode(TreeNode root) {
	traversal(root);
	//list转换为int[]
	int size = list.size();
	int[] ans = new int[size];
	for(int i = 0; i < size; i++){
	    ans[i] = list.get(i);
	}
	return ans;
    }
    //二叉搜索树中序遍历是递增顺序
    public void traversal(TreeNode root){
        if(root != null){
            traversal(root.left);
            //判断当前值与上一个值的关系, 更新 curTimes 和 preVal
            if(preVal == root.val){
                curTimes++;
            }else{
                preVal = root.val;
                curTimes = 1;
            }
            //判断当前数量与最大数量的关系, 更新 list 和 maxTimes
            if(curTimes == maxTimes){
                list.add(root.val);
            }else if(curTimes > maxTimes){
                list.clear();
                list.add(root.val);
                maxTimes = curTimes;
            }
            traversal(root.right);
        }
    }
}

Trie

Trie，又称前缀树或字典树，用于判断字符串是否存在或者是否具有某种字符串前缀。

1. 实现一个 Trie

208. Implement Trie (Prefix Tree) (Medium)

Leetcode / 力扣

这个题目的关键是数组的用法，就是说建立一个对象，对象中的数组进行实例化，不断进入对象的孩子数组中再进行实例化

class TrieNode{
    TrieNode[] child;
    boolean isEnd;
    public TrieNode(){
        child=new TrieNode[26];
        isEnd=false;
    }
}


class Trie {
    TrieNode root;

    /** Initialize your data structure here. */
    public Trie() {
        root=new TrieNode();
    }

    /** Inserts a word into the trie. */
    public void insert(String word) {
        TrieNode cur=root;
        for(int i=0;i<word.length();i++){
            char c=word.charAt(i);
            if(cur.child[c-'a']==null){
                cur.child[c-'a']=new TrieNode();
            }
            cur=cur.child[c-'a'];
        }
        cur.isEnd=true;
    }
    
    /** Returns if the word is in the trie. */
    public boolean search(String word) {
        TrieNode cur=root;
        for(int i=0;i<word.length();i++){
            char c=word.charAt(i);
            if(cur.child[c-'a']==null){
                return false;
            }
            cur=cur.child[c-'a'];
        }
        return cur.isEnd;
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    public boolean startsWith(String prefix) {
        TrieNode cur=root;
        for(int i=0;i<prefix.length();i++){
            char c=prefix.charAt(i);
            if(cur.child[c-'a']==null){
                return false;
            }
            cur=cur.child[c-'a'];
        }
        return true;

    }
}

hashmap的是实现

class TrieNode{
    HashMap<Character,TrieNode> next=new HashMap<>();
    boolean isEnd;
    public TrieNode(){
        isEnd=false;
    }
}

class Trie {
    TrieNode root;

    /** Initialize your data structure here. */
    public Trie() {
        root=new TrieNode();
    }

    /** Inserts a word into the trie. */
    public void insert(String word) {
        TrieNode cur=root;
        for(int i=0;i<word.length();i++){
            char c=word.charAt(i);
            if(!cur.next.containsKey(c)){
                cur.next.put(c,new TrieNode());
            }
            cur=cur.next.get(c);
        }
        cur.isEnd=true;
    }
    
    /** Returns if the word is in the trie. */
    public boolean search(String word) {
        TrieNode cur=root;
        for(int i=0;i<word.length();i++){
            char c=word.charAt(i);
            if(!cur.next.containsKey(c)){
                return false;
            }
            cur=cur.next.get(c);
        }
        return cur.isEnd;
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    public boolean startsWith(String prefix) {
        TrieNode cur=root;
        for(int i=0;i<prefix.length();i++){
            char c=prefix.charAt(i);
            if(!cur.next.containsKey(c)){
                return false;
            }
            cur=cur.next.get(c);
        }
        return true;

    }
}

2. 实现一个 Trie，用来求前缀和

677. Map Sum Pairs (Medium)

Leetcode / 力扣

class MapSum {
    class TrieNode{
        TrieNode[] children;
        int value;
        public TrieNode(){
            children=new TrieNode[26];
        }
    }

    private TrieNode root;

    /** Initialize your data structure here. */
    public MapSum() {
        root=new TrieNode();
    }
    
    public void insert(String key, int val) {
        TrieNode node=root;
        char[] charArray=key.toCharArray();
        for(int i=0;i<charArray.length;i++){
            int idx=charArray[i]-'a';
            if(node.children[idx]==null){
                node.children[idx]=new TrieNode();
            }
            node=node.children[idx];
        }
        node.value=val;
    }
    
    public int sum(String prefix) {
        if(prefix==null)return 0;
        TrieNode node=root;
        char[] charArray=prefix.toCharArray();
        for(int i=0;i<charArray.length;i++){
            int idx=charArray[i]-'a';
            if(node.children[idx]==null)return 0;
            node=node.children[idx];
        }
        return dfs(node);

    }

    private int dfs(TrieNode node){
        if(node==null)return 0;
        int res=node.value;
        for(TrieNode child:node.children){
            res+=dfs(child);
        }
        return res ;
    }
}

/**
 * Your MapSum object will be instantiated and called as such:
 * MapSum obj = new MapSum();
 * obj.insert(key,val);
 * int param_2 = obj.sum(prefix);
 */

 

 

算法专题训练（2）小偷问题
大锅八十小锅四十
03-13 3253
198. House Robber：小偷不能偷相邻的房子，求最大收益 class Solution(object): def rob(self, nums): size = len(nums) if size == 0: return 0 if size &lt;=2: return max(nums) Values =...
算法专题训练
Vincehex
04-13 672
专题1 简单搜索 POJ 1321 POJ 2251 POJ 3278 POJ 3279 POJ 1426 POJ 3126 POJ 3087 POJ 3414 FZU 2150 UVA 11624 POJ 3984 HDU 1241 HDU 1495 HDU 2612 专题2 搜索进阶 HDU 1043 HDU 3567 HDU 2181 HDU 3533 HDU 1560 ZOJ 2477 H...
leetcode算法专题训练：十二.动态规划专题
Worthy_Wang的博客
02-01 943
十二.动态规划专题 62.不同路径 63.不同路径2 剑指 Offer 13. 机器人的运动范围 剑指 Offer 47. 礼物的最大价值 64.最小路径和 120.三角形最小路径和 118.杨辉三角 119.杨辉三角2 343. 整数拆分 53.最大子序和 5.最长回文子串 44.通配符匹配 10.正则表达式匹配 97.交错字符串 72.编辑距离 剑指 Offer 46. 把数字翻译成字符串 91.解码方法 115.不同的子序列 139.单词拆分 140.单词拆分2 剑指 Offer 49. 丑数 剑.
算法题练习
布纸所云
08-16 530
找零 给定数组arr，arr中所有的值都是正数且不重复。每个值代表一种面值的货币，每种面值的货币可以使用任意张，再给定一个整数aim代表要找的钱数，求组成aim的最少货币数。(拓展，如果问有多少种不同的找零方法呢) 举例： arr[5,2,3]，aim=20。 4张5元可以组成20元，其他的找钱方案都要使用更多张的货币，所以返回4。 f[i]f[i]f[i]为最少用多少张组成iii数额...
二叉树根节点到叶子节点的路径数字之和
SeaSky_Steven的博客
03-16 1320
DESC: 题目描述 给定一个仅包含数字0−9\ 0-90−9 的二叉树，每一条从根节点到叶子节点的路径都可以用一个数字表示。 例如根节点到叶子节点的一条路径是1→2→31\to 2\to 31→2→3,那么这条路径就用123\ 123123 来代替。 找出根节点到叶子节点的所有路径表示的数字之和 例如： 这颗二叉树一共有两条路径， 根节点到叶子节点的路径 1→2用数字 12 代替 根节点到叶子节点的路径 1→3 用数字13 代替 所以答案为 12+13=25 示例1 输入 {...
二叉树根节点到叶子节点的所有路径和
chechenshi的博客
09-25 2939
二叉树根节点到叶子节点的所有路径和 题目描述 给定一个仅包含数字 0−9\ 0-9 0−9 的二叉树，每一条从根节点到叶子节点的路径都可以用一个数字表示。 例如根节点到叶子节点的一条路径是1→2→31\to 2\to 31→2→3,那么这条路径就用 123\ 123 123 来代替。 找出根节点到叶子节点的所有路径表示的数字之和 例如： 这颗二叉树一共有两条路径， 根节点到叶子节点的路径 1→21\to 21→2 用数字 12\ 12 12 代替 根节点到叶子节点的路径 1→31\to 31→3 用数字
LeetCode算法书阅读地址.docx
05-22
《LeetCode算法书阅读地址》是一本面向编程爱好者的资源集合，主要涵盖了各种算法和数据结构的学习路径。这本书的特点在于它并非传统的纸质书籍，而是通过LeetCode平台的在线学习资源来呈现，使得学习过程更加互动和...
leetcode中文版-leetcode:算法笔记总结。包括《剑指offer》《程序员笔试面试指南》《Leetcode》相关题目
06-29
LeetCode专题训练 回溯法： 链表 ： 动态规划： 排序专题： 程序员代码面试指南 : chapter2 : 链表部分题目： LeetCode官方算法精选 初级算法49题： 数组系列： 字符串系列 链表系列 二叉树系列 排序系列 动态规划...
LeetCode算法面试题的C++实现代码分享
- **专题训练：**针对自己的薄弱环节进行专项训练，如动态规划、字符串处理等。 - **讨论与分享：**参与 LeetCode 的社区讨论，学习别人的解题方法和思路。 - **时间管理：**在练习时，注重算法的时间复杂度，尝试...
LeetCode算法题解与代码实现
资源摘要信息:"LeetCode算法题解与分类" 描述中提到的“leetcode460-algo:某物”暗示了一组与LeetCode网站上的算法题目相关的资源。LeetCode是一个著名的在线平台，它提供了大量的编程题目，旨在帮助用户提高算法和...
LeetCode算法题解经验分享
7. 专题分类：LeetCode上的题目按照不同的主题和类型进行分类，例如数据结构、算法基础、数据库等，便于用户根据自身需要进行针对性的训练。 8. 社区互动：LeetCode有一个社区功能，用户可以浏览其他人的解决方案，...
面试手撕代码（2）
weixin_44369928的博客
08-14 1008
文章目录124. 二叉树最大路径和——后序遍历+全局变量234.回文链表——快慢指针，反转链表33.搜索旋转排序数组——二分查找543.二叉树的直径——后序遍历+全局变量两个栈实现队列——栈105.前序中序遍历构造二叉树——hashmap，递归53.最大子序和——dpdpdp优化94.二叉树中序遍历——莫里斯遍历（重点）破坏结构的版本不破坏树的原始结构110.平衡二叉树——后序遍历+剪枝20.有效的括号——栈88.合并两个有序数组103.锯齿形遍历209.长度最小的子数组141-142.环形链表113. 路
二叉树常见题
qq_44576144的博客
03-25 331
二叉树的前序遍历-递归方式 思路：创建一个List ,把打印操作改为add操作即可。 class Solution { public List<Integer> preorderTraversal(TreeNode root) { List<Integer> result=new ArrayList<>(); if(root==null){ return result; } r
算法01-学习总结
CarryNet的博客
02-21 495
1、反转链表 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 1、翻转链表 2、保存头部 head 1、循环： 思路： * 1、保存上一个节点，当前节点指向上一个节点，然后再进行下一个节点变更，直到终点。 public static Node reversal(Node...
java 算法练习题
qq_38217393的博客
11-20 1777
1. 给出一个排序好的数组和一个数，求数组中连续元素的和等于所给数的子数组 public static void main(String[] args) { int[] num = { 1, 2, 2, 3, 4, 5, 6, 7, 8, 9 }; int sum = 7; findSum(num, sum); findSum1...
每日一题——二叉树的锯齿形层次遍历
W_J_G_的博客
07-19 298
菜鸡每日一题系列打卡103天每天一道算法题目小伙伴们一起留言打卡坚持就是胜利，我们一起努力！题目描述(引自LeetCode)给定一个二叉树，返回其节点值的锯齿形层次遍历。(即先从左往右...
LeetCode：二叉树
sfklyqh的博客
01-07 512
一、二叉树锯齿形遍历 103：给定一个二叉树，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。 class Solution { public List<List<Integer>> zigzagLevelOrder(TreeNode root) { int depth = 0; Deque<TreeNode> queue = new LinkedList<>
Leedcode算法专题训练（动态规划）
kopoo的博客
10-25 860
递归和动态规划都是将原问题拆成多个子问题然后求解，他们之间最本质的区别是，动态规划保存了子问题的解，避免重复计算。 斐波那契数列 1. 爬楼梯 70. Climbing Stairs (Easy) Leetcode/力扣 题目描述：有 N 阶楼梯，每次可以上一阶或者两阶，求有多少种上楼梯的方法。 题目描述：有 N 阶楼梯，每次可以上一阶或者两阶，求有多少种上楼梯的方法。 定义一个数组 dp 存储上楼梯的方法数（为了方便讨论，数组下标从 1 开始），dp[i] 表示走到第 i 个楼梯的方法数..
剑指offer刷题
kopoo的博客
06-11 537
1、面试题43. 1～n整数中1出现的次数 输入一个整数 n ，求1～n这n个整数的十进制表示中1出现的次数。 例如，输入12，1～12这些整数中包含1 的数字有1、10、11和12，1一共出现了5次。 这个题目的核心思想是考虑：每个位是任意数字时，可以包含多少个这个位为1的数字 分了三种情况 class Solution { public int countDigitOne(int n) { //digit表示位因子，就是10、100、1000... ..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值