牛客剑指offer刷题二叉树篇

已于 2023-12-22 14:33:32 修改
阅读量175 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 算法
于 2023-11-01 09:03:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a734474820/article/details/134153675
版权

文章目录

二叉树的深度

题目

给定一个二叉树 root ，返回其最大深度。
二叉树的最大深度是指从根节点到最远叶子节点的最长路径上的节点数。

思路

采用递归的思想，分别计算根节点左右子树深度，然后比较左右子树深度大小，最大的值+1即为所求结果；

代码实现
    public static int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftDepth = maxDepth(root.left);
        int rightDepth = maxDepth(root.right);
        return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
    }

二叉树的层序遍历

题目

给你二叉树的根节点 root ，返回其节点值的层序遍历 （即逐层地，从左到右访问所有节点）。
Leetcode链接

思路

对于二叉树的层序遍历，需要利用队列的性质进行实现；

代码实现
    public static List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null) {
            return null;
        }
        List<List<Integer>> result = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node == null) {
                    continue;
                }
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
                list.add(node.val);
            }
            result.add(list);
        }
        return result;
    }

二叉搜索树中第K小的元素

题目

给定一个二叉搜索树的根节点 root ，和一个整数 k ，请你设计一个算法查找其中第 k 个最小元素（从 1 开始计数）。
LeetCode链接

思路

利用二叉搜索树中序遍历结果是排序的性质，而从计算出K个最小元素；

代码实现

	 private int count;
    private int result;
    public int kthSmallest(TreeNode root, int k) {
        if(root == null || k < 1){
            return Integer.MIN_VALUE;
        }
        inOrder(root,k);
        return result;
    }

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

重建二叉树

题目

某二叉树的先序遍历结果记录于整数数组 preorder，它的中序遍历结果记录于整数数组 inorder。请根据 preorder 和 inorder 的提示构造出这棵二叉树并返回其根节点。
注意：preorder 和 inorder 中均不含重复数字。
LeetCode链接

思路

首次，由前序遍历可知，数组中第一个数即为二叉树的root节点，则可以根据root节点的值去中序遍历数组中查找对应root的下标，根据root下标位置，可以分别得到左右子树，然后利用递归依次重建左右子树；

代码实现
    public static TreeNode deduceTree(int[] preorder, int[] inorder) {
        if (preorder == null || inorder == null || preorder.length == 0) {
            return null;
        }
        int length = inorder.length;
        int rootValue = preorder[0];
        int rootIndex = 0;
        for (int i = 0; i < inorder.length; i++) {
            if (inorder[i] == rootValue) {
                rootIndex = i;
            }
        }

        TreeNode result = new TreeNode(rootValue);
        result.left = deduceTree(Arrays.copyOfRange(preorder, 1, 1 + rootIndex), Arrays.copyOfRange(inorder, 0, rootIndex));
        result.right = deduceTree(Arrays.copyOfRange(preorder, 1 + rootIndex, preorder.length), Arrays.copyOfRange(inorder, rootIndex + 1, inorder.length));
        return result;
    }

树的子结构

题目

给定两棵二叉树 tree1 和 tree2，判断 tree2 是否以 tree1 的某个节点为根的子树具有相同的结构和节点值 。
注意，空树不会是以 tree1 的某个节点为根的子树具有相同的结构和节点值 。
LeetCode链接

思路

当tree2是tree1的子树时，则说明tree1的某个根节点一定等于tree2的根节点，我们递归遍历找到相等的根节点后，再判断对应根节点的左右子树是否相等即可；

代码实现
 public boolean isSubStructure(TreeNode A, TreeNode B) {
        if(A == null || B == null){
            return false;
        }
        //A树当前节点相等 || A树的左子树包含B树 || A树的右子树包含B树
        return isSubSuccess(A,B) || isSubStructure(A.left,B) || isSubStructure(A.right,B);
    }

    public boolean isSubSuccess(TreeNode A, TreeNode B){
        if(B == null){
            return true;
        }
          if(A == null){
            return false;
        }
    	//当此节点值相等，再判断左右子树是否相等
        return A.val == B.val && isSubSuccess(A.left,B.left) &&  isSubSuccess(A.right,B.right);
    }

二叉树镜像

题目

LCR 144. 翻转二叉树
给定一棵二叉树的根节点 root，请左右翻转这棵二叉树，并返回其根节点。
LeetCode

思路

二叉树镜像
对比二叉树反转结果可以看出：整体遍历二叉树，如果当前节点是非叶子节点，则需要交换其左右子节点，当整体遍历结束，即得出结果；

代码实现
 public TreeNode mirrorTree(TreeNode root) {
         if (root == null) {
            return null;
        }
        if (root.left == null && root.right == null) {
            return root;
        }
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
        if (root.left != null) {
            mirrorTree(root.left);
        }
        if (root.right != null) {
            mirrorTree(root.right);
        }
        return root;
    }

从上往下打印二叉树

题目

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。例如，输入图4.6中的二叉树，则依次打印出8，6，10，5，7，9，11.
从上往下打印二叉树

思路

利用队列先进先出的性质，首先将根节点push进队列，然后从队列中取出根节点，存下来，同时将根节点对应的左右子节点push进队列，如此操作，直到队列为空为止；

代码实现
 private  static List<Integer> printFromTopToBottom(TreeNode root) {
        if (root == null) {
            return null;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        List<Integer> result = new ArrayList<>();
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if (node == null) {
                continue;
            }
            result.add(node.value);
            if (node.left != null) {
                queue.add(node.left);
            }
            if (node.right != null) {
                queue.add(node.right);
            }
        }
        return result;
    }

验证二叉搜索树的后序遍历序列

题目

请实现一个函数来判断整数数组 postorder 是否为二叉搜索树的后序遍历结果。
LeetCode链接

思路

1.根据后序遍历可知，数组最后一个元素为根节点；
2.根据二叉搜索树性质可知，根节点对应左子树都不大于根节点，右子树都不小于根节点；
3.遍历数组可以计算得到左右子树对应的范围；
4.判断左右子树是否同时满足二叉搜索树性质即可；

代码实现
    public static boolean verifyTreeOrder(int[] postorder) {
        if (postorder == null || postorder.length == 0) {
            return true;
        }
        int length = postorder.length;
        //1.获取到根节点
        int rootValue = postorder[length - 1];
        //2.遍历找出左子树范围
        int leftIndex;
        for (leftIndex = 0; leftIndex < length - 1; leftIndex++) {
            if (postorder[leftIndex] > rootValue) {
                break;
            }
        }
        //3.根据左子树范围可以知道右子树范围，从而进行数据判断
        int rightIndex;
        for (rightIndex = leftIndex; rightIndex < length - 1; rightIndex++) {
            if (postorder[rightIndex] < rootValue) {
                return false;
            }
        }
        //4.分别验证左右子树是否是搜索二叉树
        boolean isLeftSuccess = true;
        if (leftIndex > 0) {
            isLeftSuccess = verifyTreeOrder(Arrays.copyOfRange(postorder, 0, leftIndex));
        }
        boolean isRightSuccess = true;
        if (leftIndex < length - 1) {
            isRightSuccess = verifyTreeOrder(Arrays.copyOfRange(postorder, leftIndex, length - 1));
        }
        return isLeftSuccess && isRightSuccess;

    }

二叉树中和为某一值的路径(一)

题目

描述
给定一个二叉树root和一个值 sum ，判断是否有从根节点到叶子节点的节点值之和等于 sum 的路径。
1.该题路径定义为从树的根结点开始往下一直到叶子结点所经过的结点
2.叶子节点是指没有子节点的节点
3.路径只能从父节点到子节点，不能从子节点到父节点
4.总节点数目为n

代码实现
  public boolean hasPathSum (TreeNode root, int sum) {
       if(root == null){
         return false;
       }
        sum -=root.val;
        if(root.left == null && root.right == null && sum == 0){    
        	//当到达叶子节点时，判断sum是否为0即可
            return true;
        }
        return hasPathSum(root.left,sum) || hasPathSum(root.right,sum);

    }

二叉树中和为某一值的路径(二)

题目

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。
叶子节点 是指没有子节点的节点。
LeetCode链接

思路

从根节点开始,分别顺着左右子树往下查找，沿途使用集合进行求和计算，当到达叶子节点时，判断此时集合元素之和是否为target，如果是则进行对应保存，否则返回其对应头结点，继续递归查找；

代码实现
 private static List<List<Integer>> result = new ArrayList<>();
 /**
 * 二叉树中和为某一值的路径
 */
 public static List<List<Integer>> pathTarget(TreeNode root, int target) {
        if (root == null) {
            return null;
        }
        bfs(root, target, new ArrayList<>());
        return result;
    }

    private static void bfs(TreeNode root, int target, ArrayList<Integer> list) {
        if (root == null) {
            return;
        }
        list.add(root.val);
        bfs(root.left, target - root.val, list);
        bfs(root.right, target - root.val, list);
        if (root.left == null && root.right == null && target == root.val) {
            //表示已经到了叶子节点
            result.add(new ArrayList<>(list));
        }
        //回溯到上一层节点
        list.remove(list.size() - 1);
    }

二叉树中和为某一值的路径(三)

题目

描述
给定一个二叉树root和一个整数值 sum ，求该树有多少路径的的节点值之和等于 sum 。
1.该题路径定义不需要从根节点开始，也不需要在叶子节点结束，但是一定是从父亲节点往下到孩子节点
2.总节点数目为n
3.保证最后返回的路径个数在整形范围内(即路径个数小于231-1)

代码实现
private int res;
    public int FindPath (TreeNode root, int sum) {
        // write code here
        if(root == null){
            return res;
        }
        dfs(root,sum);
        FindPath(root.left,sum);
        FindPath(root.right,sum);
        return res;
    }

    private void dfs(TreeNode root,int sum){
        if(root == null){
            return;
        }
        // 存在符合要求的值即可
        if(root.val == sum){
            res++;
        }
        dfs(root.left,sum - root.val);
        dfs(root.right,sum - root.val);
    }

将二叉搜索树转化为排序的双向链表

题目

将一个 二叉搜索树 就地转化为一个 已排序的双向循环链表 。

对于双向循环列表，你可以将左右孩子指针作为双向循环链表的前驱和后继指针，第一个节点的前驱是最后一个节点，最后一个节点的后继是第一个节点。

特别地，我们希望可以 就地 完成转换操作。当转化完成以后，树中节点的左指针需要指向前驱，树中节点的右指针需要指向后继。还需要返回链表中最小元素的指针。
LeetCode链接

思路

思路: 由二叉搜索树性质可知，中序遍历结果是排序的，因此我们只需要将中序遍历结果形成双向链表即可；

  1. 定义 head 、prev 节点分别表示头节点以及当前遍历的前驱节点；
  2. 当prev节点不为空时，可直接将prev.right = root；
  3. 当prev节点为空时，说明当前遍历节点为头结点，对head进行赋值 head = root;
  4. 由于是双向链表，则需要将root.left = prev;
  5. 而后将prev移动到下一个root节点，直到完成中序遍历
  6. 最终记得将prev和head节点首尾相连，prev.right = head; head.left = prev;

将二叉搜索树转化为排序的双向链表

代码实现
// 定义head和prev节点
public Node head,prev; 


public Node treeToDoublyList(Node root) {
     if(root == null){
         return root;
     }
     inOrder(root);
     //中序遍历结束，不要忘记首尾连接
     head.left = prev;
     prev.right = head;
     return head;
    }

    public void inOrder(Node root){
        if(root == null){
            return;
        }
        inOrder(root.left);
        if(prev != null){
            prev.right = root;
        } else {
            head = root;
        }
        root.left = prev;
        prev = root;
        inOrder(root.right);
    }

判断是不是平衡二叉树

题目

输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。
LeetCode链接

思路

采用递归思想，依次计算各个节点左右子树高度相差值是否超过1，超过1则非平衡二叉树；

代码实现
 public boolean isBalanced(TreeNode root) {
        if(root == null){
            return true;
        }
        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);
        if(Math.abs(leftHeight - rightHeight) <= 1){
            return isBalanced(root.left) && isBalanced(root.right);
        }
        return false;
    }

    private int getHeight(TreeNode node){
        if(node == null){
            return 0;
        }
        int leftHeight = getHeight(node.left);
         int rightHeight = getHeight(node.right);
        return Math.max(leftHeight,rightHeight) + 1;
    }

二叉树的下一个节点

题目

给定一颗二叉树和其中的一个节点，如何找出中序遍历序列的下一个节点？树中的节点除了有两个分别指向左、右子树的指针，还有一个指向父节点的指针；

思路

二叉树的下一个节点
图示中二叉树的中序遍历结果为[d,b,h,e,i,a,f,c,g],通过简单分析，我们可以得出下面结论：

  1. 如果当前节点存在右子树，则其中序遍历的下一个节点为其右子树中的最左子节点；（如a下一个节点为g）；
  2. 如果当前节点不存在右子树，则其中序遍历的下一个节点需要往上遍历，找它父节点…直到当前节点的父节点左孩子是当前节点，那么它的下一个节点就是当前节点的父节点；（如h节点，往上遍历是e的左孩子，则e为其下一个节点，如i节点，往上遍历，直到到达节点b时，b是其父节点a的左节点，则a为下一个节点）；
代码实现
 public static TreeNode getNext(TreeNode node) {
        if (node == null) {
            return null;
        }
        //1.当前节点的右子树不为空，则中序遍历的下一个节点为右子树中最左节点；
        if (node.right != null) {
            node = node.right;
            while (node.left != null) {
                node = node.left;
            }
            return node;
        }
        //2.当前节点的右子树为空，则中序遍历的下一个节点需要从下往上遍历，直到找到一个节点的父节点的左孩子是当前节点为止，返回其父节点;
        while (node.parent != null) {
            if (node.parent.left == node) {
                return node.parent;
            } else {
                node = node.parent;
            }
        }
        return null;
    }


    private static class TreeNode {
        String value;
        TreeNode left;
        TreeNode right;
        TreeNode parent;

        public TreeNode(String value) {
            this.value = value;
        }
    }

对称二叉树

题目

给你一个二叉树的根节点 root ， 检查它是否轴对称。
对称二叉树
LeetCode链接

思路

我们可以针对二叉树前序遍历定义一种新的遍历方式，先进行右节点遍历在进行左节点遍历，再与前序遍历结果对比，若两者一致，则表示当前二叉树为对称二叉树；

代码实现
 public static boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }
        return isSymmetric(root, root);
    }

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

从上到下打印二叉树

题目

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
从上到下打印二叉树

思路

我们知道，从上到下打印二叉树采用队列的思路，这里我们需要记录当前层级需要打印节点个数以及下一层需要打印节点个数，这样采用队列思路，即可实现如上打印效果；

代码实现
	/**
     * 剑指offer 分行从上到下打印二叉树
     *
     * @param root
     */
    private static void print(TreeNode root) {
        if (root == null) {
            return;
        }
        int nextLevelNum = 0; //表示下一层需要打印节点个数
        int needPrintNum = 1; //表示本层需要打印的节点个数
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if (node == null) {
                continue;
            }
            if (node.left != null) {
                nextLevelNum++;
                queue.add(node.left);
            }
            if (node.right != null) {
                nextLevelNum++;
                queue.add(node.right);
            }
            System.out.print(node.value+" ");
            needPrintNum--;
            if (needPrintNum == 0) {
                System.out.println();
                needPrintNum = nextLevelNum;
                nextLevelNum = 0;
            }
        }
    }

序列化二叉树

题目

请实现两个函数，分别用来序列化和反序列化二叉树。

思路

采用前序遍历思想，各个节点之间使用特殊符号进行拼接，当节点为null时，需要拼接上"NULL"，从而实现序列化；
当反序列化时，根据特殊符号进行拆分，而从将数据丢入队列中，从而完成反序列化；

代码实现

    /**
     * 序列化二叉树
     *
     * @param root
     * @return
     */
    public static String serialByPreOrder(Node root) {
        if (root == null) {
            return "NULL_";
        }
        StringBuilder result = new StringBuilder();
        result.append(root.val + "_");
        result.append(serialByPreOrder(root.left));
        result.append(serialByPreOrder(root.right));
        return result.toString();
    }


    /**
     * 二叉树的反序列号
     *
     * @param res
     * @return
     */
    public static Node reconByPreOrderStr(String res) {
        if (res == null || res.length() == 0) {
            return null;
        }
        String[] array = res.split("_");
        Queue<String> queue = new LinkedList<>();
        for (int i = 0; i < array.length; i++) {
            queue.add(array[i]);
        }
        return reconByQueue(queue);
    }

    private static Node reconByQueue(Queue<String> queue) {
        String poll = queue.poll();
        if ("NULL".equals(poll)) {
            return null;
        }
        Node head = new Node(Integer.valueOf(poll));
        head.left = reconByQueue(queue);
        head.right = reconByQueue(queue);
        return head;
    }

二叉树的最近公共祖先

题目

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

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

思路

分为3种情况：

  1. p、q节点一个在左子树，一个在右子树，则最近公共祖先为当前节点；
  2. p、q节点都处于左子树上；
  3. p、q节点都处于右子树上；
代码实现
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null){
            return root;
        }
        if(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){
             //说明 p q一个在左子树 一个在右子树
             return root;
         }
         if(left != null){
             // p、q节点都处于左子树上
             return left;
         }
         if(right != null){
         	// p、q节点都处于右子树上
             return right;
         }
         return null;
    }

二叉搜索树的最近公共祖先

题目

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

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

思路

与上一题二叉树的最近公共祖先一样，同样存在三种情况；

  1. p、q节点一个在左子树，一个在右子树，则最近公共祖先为当前节点；
  2. p、q节点都处于左子树上；
  3. p、q节点都处于右子树上；
    但由于是二叉搜索树，我们可以利用相关性质进行优化；
代码实现
 public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null){
            return null;
        }
        //当p、q都小于root时，说明p、q都处于左子树上
        if(p.val < root.val && q.val < root.val){
            return lowestCommonAncestor(root.left,p,q);
        }
        //当p、q都大于root时，说明p、q都处于右子树上
        if(p.val > root.val && q.val > root.val){
            return lowestCommonAncestor(root.right,p,q);
        }
        //否则，最近公共结点就是当前节点
        return root;
    }
惜许
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
offer:牛客剑指offer
05-06
《牛客剑指Offer》是Java开发者们非常关注的一套面试题集，它涵盖了大量面试中常见的编程问题，旨在帮助求职者提升技能，顺利通过面试。这个压缩包"offer-master"很可能包含了该题集的源代码或者解决方案。下面，...
offer_牛客_剑指offer_剑指Offer算法题编程代码解析汇总_
10-02
《剑指Offer：牛客网算法题编程代码解析汇总》 在编程领域，尤其是在面试准备过程中，"剑指Offer"是一本备受推崇的书籍，它集合了大量的算法题目，旨在提升程序员在解决实际问题中的能力。牛客网作为国内知名的在线...
剑指offer题解(C++).docx
07-17
《剑指Offer题解》是针对面试准备的一份宝贵资源，由Sidney.Tan精心整理，结合了牛客网上的讨论、《剑指Offer》书中的解法以及个人的编程实践，提供了全面的代码和思路解析。这份文档按照牛客网上的题目顺序，覆盖了...
剑指offer（java版）----牛客.zip
09-20
《剑指Offer》是经典的一本面试准备书籍，主要针对计算机科学与技术领域的求职者，尤其是对Java开发者具有很高的参考价值。这本书源自牛客网，一个专注于编程技能测试和在线编程竞赛的平台，旨在帮助求职者提升编程...
算法-KMP字符串匹配
xx_xb的博客
07-23 180
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
【LeetCode】141.环形链表、142. 环形链表 II（算法 + 图解）
最新发布
明志の博客
07-25 878
环形链表
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 662
AtCoder Beginner Contest 363 ABCDE
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 763
二叉搜索树向左或向右指明方向，不用遍历整个树。
数据结构与算法--【数组2】力扣练习 || 双指针 / 移除元素 / 数组排序
qq_44578108的博客
07-25 524
简单删除元素 / 指定某元素位置，其余元素位置相对不变双指针指向数组头。快指针扫描数组并判断，慢指针收集变化后的数组元素。不创建新数组，只覆盖原数组。对数组元素排序一个指针指开头，一个指针指结尾。判断两指针指向值大小，循环结束条件first <= last；for循环，while循环均可，本人更习惯while循环。使用malloc为新数组分配空间，注意，创建了新数组。
河南萌新联赛2024第（二）场：南阳理工学院
a13997460860的博客
07-25 670
这场比赛里面出到了很多的题，都是需要很多的时间去写，主要考察到了代码的实现能力，与codeforces里面的题有些差距。codeforces打多了还是有点不习惯的。题挺好的，尤其是H题感觉很考代码实现能力与STL的使用熟练度。多写写这样的题还是对我们很有好处的。只不过前三题都太水了，没有一点难度。
python基础知识点（蓝桥杯python科目个人复习计划73）
m0_73523976的博客
07-25 141
（1）100万元正好被分成若干份，不能有剩余。1 <= |s| <= 5 * 10^5,保证s只包含大写字母、小写字母和数字。地产大佬先生临终的遗愿是拿出100万元给x社区的居民抽奖。1 <= |s| <= 10^6，保证s只包含大小写字母。给定一个长度为n的字符串s，请你判断字符串s是否回文。（3）在满足上述条件的情况下，分成的份数越多越好。给定一个字符串s，请你求出s的最长回文字符串。若字符串s为回文串，则输出Y，否则输出N。输出共1行，包含一个整数，表示答案。输入仅一行包含一个字符串s。
算法力扣刷题记录 五十六【501.二叉搜索树中的众数】
danaaaa的博客
07-21 917
求众数方法
代码随想录算法训练营day8 | 344.反转字符串、541.反转字符串 II、卡码网：54.替换数字
m0_55763458的博客
07-25 448
代码随想录算法训练营day8 | 344.反转字符串、541.反转字符串 II、卡码网：54.替换数字
SMO算法，platt论文的原始算法及优化算法
Rhett_Butler0922的博客
07-25 160
platt论文的原始SMO算法、一种优化算法、及libsvm算法。
三维点云中常用的表面重建算法
Argulo的博客
07-22 1167
表面重建算法起源于计算机视觉和计算几何学领域。早期的研究集中在从二维图像中提取三维信息。然而，随着三维扫描技术的进步，越来越多的研究转向了如何从点云数据中重建表面。三维点云表面重建技术的发展，始于20世纪90年代，主要推动力是激光扫描和结构光扫描的广泛应用。
DP 整数拆分&不同的二叉搜索树 DAY21
小木公的博客
07-25 625
没完全消化，特别是递推公式…我觉得是,另外还需要取最大值如何理解？//为什么是n + 1?//初始化dp[2] = 1;i <= n;j++){这道题想到用动规的方法来解决，就不太好想，需要举例，画图，分析，才能找到递推的关系。
2024.7.24 作业
qq_64434282的博客
07-24 598
【代码】2024.7.24 作业。
2024 暑假友谊赛-热身2
qq_42643660的博客
07-24 670
树的直径，N%m=N-(N/m)*m，期望dp..迷，简单线段树
牛客Verilog刷题
08-05
在牛客网上刷题也包括Verilog语言的题目，Verilog是一种硬件描述语言，用于描述数字电路和系统级集成电路。在Verilog刷题中，常见的内容包括时序逻辑实现、组合逻辑实现以及状态机设计等。常见的Verilog语言知识点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值