数据结构（Java）：力扣 二叉树面试OJ题（二）【进阶】

已于 2024-08-16 16:56:33 修改
阅读量1.4k 收藏 16
点赞数 42
分类专栏： 数据结构（Java） 文章标签： leetcode 数据结构 java 开发语言 算法 面试
于 2024-07-17 22:58:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_83595513/article/details/140480592
版权

目录

💎 1、题一：二叉树的层序遍历

🌟 1.1 思路1（递归求解） 

🌟 1.1.1 思路1代码

🔆 1.2 思路2（队列求解）

🔆 1.2.1 思路2代码 

 💎 2、题二：判断是否为完全二叉树

🌟 2.1 思路分析

  🌟 2.2 代码

💎  3、题三：求二叉树中节点的最近公共祖先 

🌟 3.1 思路分析

 🌟 3.2 代码

💎  4、题四：根据二叉树创建字符串

🌟 4.1 思路分析

 🌟 4.2 代码

💎  5、题五：二叉树前序遍历递归实现与非递归实现

🌟 5.1 递归实现->思路分析

 🌟 5.1.1 递归实现->代码

🔆 5.2 非递归实现->思路分析

🔆 5.2.1 非递归实现->代码 

💎  6、题六：二叉树中序遍历递归实现与非递归实现

🌟 6.1 递归实现->代码

🔆 6.2 非递归实现->代码

 💎  7、题七：二叉树后序遍历递归实现与非递归实现

🌟 7.1 递归实现->代码

🔆 7.2 非递归实现->思路分析

 🔆 7.2.1 非递归实现->代码 

 💎  8、题八：根据前序和中序遍历序列构建二叉树

 🌟 8.1 思路分析

 🌟 8.1 代码

 💎  9、题九：根据后序和中序遍历序列构建二叉树

  🌟 9.1 思路分析

   🌟 9.2 代码​​​​​​

💎 1、题一：二叉树的层序遍历

. - 力扣（LeetCode）

层序遍历， 即从上到下，从左到右，一层一层的将数据遍历一遍。 

🌟 1.1 思路1（递归求解） 

  1. 首先，根据上篇求树高度的方法，求出二叉树的高度。接着，实例化出高度个一维顺序表添加到二维顺序表中。
  2. 记录好每层数据的层数，根据层数并按顺序来将来将数据添加到二维顺序表的第几行中（记录层数来放入数据，是解题关键点！！！）。
  3. 默认根节点是第0层，与顺序表下标相对应。
  4. 这里以前序遍历的思想递归，添加各层数据。

🌟 1.1.1 思路1代码

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> listVal = new ArrayList<>();
        if(root == null) {
            //注意：若根节点为空，要返回空的顺序表
            return listVal;
        };
        int height = treeHeight(root);
        for(int i = 0; i < height; i++) {
            List<Integer> list = new ArrayList<>();
            listVal.add(list);
        }
        //根节点的层数默认为0
        addNode(root,0,listVal);
        return listVal;
    }
    //求树高度
    public int treeHeight(TreeNode root) {
        if(root == null) return 0;
        return Math.max(treeHeight(root.left),treeHeight(root.right)) + 1;
    }
    public void addNode(TreeNode root,int level,List<List<Integer>> listVal) {
        if(root == null) {
            return;
        }
        //以前序遍历的思想，根据层数来将数据添加到该行的顺序表中
        listVal.get(level).add(root.val);
        addNode(root.left,level+1,listVal);
        addNode(root.right,level+1,listVal);
    } 
}


🔆 1.2 思路2（队列求解）

  1. 首先创建一个队列，将根节点放入队列当中
  2. 每次循环前记录队列中元素个数size，依次出队size个元素，每次出队的元素（节点）都要判断其左右子树是否为空，若不为空则添加到队列中
  3. 将每次出队的元素的val值添加到一维顺序表中，size个元素全部出队完后，将这个一维顺序表添加到二维顺序表中，也就是说，每size个出队的元素都是同一层的节点
  4. 循环以上过程，直至元素全部添加至二维顺序表中（队列为空）

🔆 1.2.1 思路2代码 

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> listVal = new ArrayList<>();
        if (root == null) {
            //注意：若根节点为空，要返回空的顺序表
            return listVal; 
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        //队列空时，说明节点已全部添加到二维顺序表中
        while (!queue.isEmpty()) {
            int size = queue.size();
            //存储每一层节点的顺序表
            List<Integer> list = new ArrayList<>();
            //将队列中的size个元素依次出队，
            //并判断其左右子树是否为空，若不为空则添加到队列中
            while (size != 0) {
                TreeNode out = queue.poll();
                list.add(out.val);
                if (out.left != null) {
                    queue.offer(out.left);
                }
                if (out.right != null) {
                    queue.offer(out.right);
                }
                size--;
            }
            //将每一层的一维顺序表添加到二维顺序表中
            listVal.add(list);
        }
        return listVal;
    }
}

 💎 2、题二：判断是否为完全二叉树

 本题无链接，

题目即：给出一棵树的根节点，判断是否为完全二叉树。

🌟 2.1 思路分析

这题的解题思路和上一题队列求解差不多，都是借助队列这一数据结构：

  1. 首先，创建队列，放入根节点。
  2. 将一个元素出队，cur接收出队元素，判断cur是否为空，若cur不为空，则将其左右孩子放入队列中（若左右子树为null，也要将null入队），循环这一过程。
  3. 当cur为null时结束循环（出队的是null，cur接收，此时cur为null），此时，只要判断队列中的剩余元素是否存在非null元素：若剩余元素全为null则说明该树为完全二叉树；若剩余元素存在非null元素则说明该树不为完全二叉树。

  🌟 2.2 代码

boolean isCompleteTree(TreeNode root) {
        if(root == null) {
            return true;
        }
        //创建队列 添加根节点
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        //当cur不为空时，添加其左右孩子
        TreeNode cur = root;
        while (cur != null) {
            cur = queue.poll();
            if (cur != null) {
                queue.offer(cur.left);
                queue.offer(cur.right);
            }
        }
        //cur为空时，判断队列中是否有非空元素
        //若剩余元素全为null则说明该树为完全二叉树；
        // 若剩余元素存在非null元素则说明该树不为完全二叉树。
        boolean flg = false;
        while (!queue.isEmpty()) {
            TreeNode cur2 = queue.poll();
            if (cur2 != null) {
                flg = true;
            }
        }
        if (flg == true) {
            return false;
        }else {
            return true;
        }
    }

💎  3、题三：求二叉树中节点的最近公共祖先 

. - 力扣（LeetCode）

🌟 3.1 思路分析

  • ①：当p、q在根节点的左右子树上时，祖先就是这个根节点
  • ②：当p、q都在根节点的右子树上时，由于节点的祖先可以是它自己，所以祖先就是p或q本身
  • ③：当p、q都在根节点的左子树上时，由于节点的祖先可以是它自己，所以祖先就是p或q本身
  • 以前序遍历思想递归，若遇见p、q节点便返回
  • 若左右子树都有返回值，说明祖先就是这个根节点；（对于第一层的根节点）若只有左子树有返回值，说明p、q均在左子树上，返回的节点就是最近祖先；（对于第一层的根节点）若只有右子树有返回值，说明p、q均在右子树上，返回的节点就是最近祖先。

 🌟 3.2 代码

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        return findNode( root,  p,  q);

    }
    public TreeNode findNode(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null) {
            return null;
        }
        //先判断根节点是否为p、q节点
        if(root.val == p.val || root.val == q.val) {
            return root;
        }
        //查找左右子树
        TreeNode leftNode = findNode(root.left,p,q);
        TreeNode rightNode = findNode(root.right,p,q);   

        //若左右子树都有返回值，说明祖先就是这个根节点    
        if(leftNode != null && rightNode != null) {
            return root;
        }
        //在左树上找到了
        if(leftNode != null && rightNode == null) {
            return leftNode;
        }
        //在右树上找到了
        if(rightNode != null && leftNode == null) {
            return rightNode;
        }
        return null;
    }
}

💎  4、题四：根据二叉树创建字符串

. - 力扣（LeetCode）

🌟 4.1 思路分析

  1. 借助StringBuffer拼接字符串，最后返回字符串
  2. 以前序遍历思想递归
  3. 拼接当前根节点，判断根节点的左孩子是否为空，若左孩子不为空则拼接"("，并递归左子树；若左孩子为空且右孩子为空，则直接返回即可；若左孩子为空但右孩子不为空，注意！！！此时应该拼接"()"，继续递归右子树。
  4. 若右孩子为空，则直接返回；若右孩子不为空，则拼接"("并递归右子树。
  5. 在根节点的左右子树完成即递归回退后拼接相应的")"
  6. 调用toString方法返回字符串

 🌟 4.2 代码

 class Solution {
    StringBuilder stringBuilder = new StringBuilder();
    public String tree2str(TreeNode root) {
        tree2strChild(root);
        return stringBuilder.toString();
    }
    public void tree2strChild(TreeNode root) {
        if(root == null) {
            return ;
        }
        stringBuilder.append(root.val);
           if(root.left != null) {
            //左子树不为空，则必然添加"("
            stringBuilder.append("(");
            //递归左子树
            tree2strChild(root.left);
            //该节点左子树完，则拼接")"
            stringBuilder.append(")");
        }else {
            //左子树为空，且右子树为空，直接返回
            if(root.right == null) {
                return;
            }else {
            //左子树为空，但右子树不为空，需拼接"()"
            stringBuilder.append("()");
            }
        }
        //若右孩子为空，则直接返回；若右孩子不为空，则拼接"("并递归右子树
        if (root.right != null) {
            stringBuilder.append("(");
            tree2str(root.right);
            stringBuilder.append(")");
        }else {
            return;
        }
    }
}

💎  5、题五：二叉树前序遍历递归实现与非递归实现

 . - 力扣（LeetCode）

🌟 5.1 递归实现->思路分析

递归实现前序遍历的思想很简单：就是先将根节点的数据放入顺序表中，再将左子树的数据放入顺序表中， 再将右子树的数据放入顺序表中。

 🌟 5.1.1 递归实现->代码

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root == null) {
            return list;
        }
        list.add(root.val);
        List<Integer> leftList = preorderTraversal(root.left);
        list.addAll(leftList);

        List<Integer> rightList = preorderTraversal(root.right);
        list.addAll(rightList);

        return list;
    }
}

🔆 5.2 非递归实现->思路分析

 非递归实现遍历，我们需要借助一种数据结构--->栈

注意：本题要求将数值放入顺序表中，返回顺序表。故这里访问根节点时，对根节点的操作是将根节点的val值添加到顺序表中。 

  1. 创建栈和顺序表，将根节点赋值给cur
  2. 将cur入栈并将cur的val值添加到顺序表中，cur更新为cur的left，接着将cur入栈并将cur的val值添加到顺序表中。循环操作，直到cur为空
  3. 此时cur为空，pop弹出栈顶元素赋给top，将cur更新为top.right；若top.right为空，即更新的cur为空，则继续弹出栈顶元素（top接收），直至cur不为空。
  4. 此时cur不为空，循环2、3步骤，直至栈中元素为空，说明树中元素已按照前序遍历的方式全部添加到了顺序表中。

 🔆 5.2.1 非递归实现->代码 

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;

        //注意这里的循环条件
        //因为后续cur为空时要弹出栈顶元素，故栈不能为空
        //且一开始时栈为空，故cur不为空就可进入循环
        //当栈空且cur为空，说明前序遍历已完成
        while (cur != null || !stack.isEmpty()) {
            //cur不为空就要进栈，并添加进顺序表
            //cur = cur.left
            while (cur != null) {
                stack.push(cur);
                list.add(cur.val);
                cur = cur.left;
            }
            //当cur为空时，弹出栈顶元素（top），赋给cur其右子树
            //若cur还是为空（top.right为空），循环过来继续弹出元素，并赋给cur新的top.right
            TreeNode top = stack.pop();
            cur = top.right;
        }
        return list;
    }
}

💎  6、题六：二叉树中序遍历递归实现与非递归实现

. - 力扣（LeetCode）

中序遍历的实现，不管是在递归实现上还是在非递归实现上，和前序遍历的思想都是相同的，只是访问根节点的时机有所不同。

🌟 6.1 递归实现->代码

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>(); 
        if(root == null) {
            return list;
        }
        

        List<Integer> listLeft = inorderTraversal(root.left);
        list.addAll(listLeft);

        list.add(root.val);

        List<Integer> listRight = inorderTraversal(root.right);
        list.addAll(listRight);

        return list;
    }
}

🔆 6.2 非递归实现->代码

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;

        //注意这里的循环条件
        //因为后续cur为空时要弹出栈顶元素，故栈不能为空
        //且一开始时栈为空，故cur不为空就可进入循环
        //当栈空且cur为空，说明前序遍历已完成
        while (cur != null || !stack.isEmpty()) {
            //cur走左子树
            while (cur != null) {
                stack.push(cur);

                cur = cur.left;
            }
            //当cur为空时，弹出栈顶元素（top），添加进顺序表，赋给cur其右子树
            //若cur还是为空（top.right为空），循环过来继续弹出元素，并赋给cur新的top.right
            TreeNode top = stack.pop();
            list.add(top.val);
            cur = top.right;
        }
        return list;
    }
}

 💎  7、题七：二叉树后序遍历递归实现与非递归实现

. - 力扣（LeetCode）

 后序遍历的实现，在递归上，与前序、中序遍历的思想是相同的，在此不再赘述。

而在非递归的实现上，后序遍历需要额外注意几点。

🌟 7.1 递归实现->代码

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root == null) {
            return list;
        }

        List<Integer> list1 = postorderTraversal(root.left);
        list.addAll(list1);
        List<Integer> list2 = postorderTraversal(root.right);
        list.addAll(list2);
        list.add(root.val);
        return list;
    }
}

🔆 7.2 非递归实现->思路分析

 后序遍历在非递归的实现上，需要额外注意几点：

  1. 当cur为空时，不可直接将栈顶元素弹出并添加进顺序表（或打印，只是访问根节点时的操作不同）
  2. 因为栈顶元素即根节点，后序遍历，需要判断栈顶元素的右孩子是否为空，若为空，才可弹出栈顶元素并打印；若右孩子不为空，需要先对右子树中的元素进行入栈和打印操作
  3. 而当栈顶元素的右孩子不为空时，我们又需要额外注意一点！！！当栈顶元素的右孩子不为空时，那就说明这个栈顶元素将永远不能出栈，会造成死循环！！！我们需要记录进过栈的元素，避免死循环的出现！！！ 

发生死循环过程如下图：

 🔆 7.2.1 非递归实现->代码 

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;

        //prev指向被打印过的节点
        TreeNode prev = null;
        //注意这里的循环条件
        //因为后续cur为空时要弹出栈顶元素，故栈不能为空
        //且一开始时栈为空，故cur不为空就可进入循环
        //当栈空且cur为空，说明前序遍历已完成
        while (cur != null || !stack.isEmpty()) {
            //cur走左子树
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }

            //当cur为空时，不可直接将栈顶元素弹出和添加进顺序表
            //要判断栈顶元素（根节点）是否有右孩子
            //若右孩子为空可以弹出和添加
            //若右孩子不为空，需要先将右子树的元素入栈并添加
            TreeNode top = stack.peek();
            //当栈顶元素的右孩子入过栈时，此时栈顶元素可以弹出并添加进顺序表
            if(top.right == null || top.right == prev) {
                stack.pop();
                list.add(top.val);
                prev = top;
            }else {
                cur = top.right;
            }
        }
        return list;
    }
}

 💎  8、题八：根据前序和中序遍历序列构建二叉树

 . - 力扣（LeetCode）

 🌟 8.1 思路分析

根据前序遍历序列，我们可以确定根节点；通过中序遍历序列，我们又可以找到这个根节点的左子树和右子树；递归下去，我们就可以创建出整棵树来。

  1. 前序遍历：根-》左子树-》右子树    中序遍历：左子树-》根-》右子树
  2. 我们遍历前序序列找到根节点，接着从中序序列中找到根节点root，根节点的左侧就是左子树序列，右侧就是右子树序列，我们记录当前树的起始位置下标start和结束位置下标end。
  3. 继续遍历前序序列，因为前序序列的顺序为根 左 右的顺序，所以下一个节点是其左子树的根节点，所以应该先递归创建左子树再递归创建右子树，在递归回退的过程中完成节点间的连接。
  4. 每次递归创建左子树时，end=root-1
  5. 每次递归创建右子树时，start=root+1
  6. 当end>start时说明当前节点已无左右子树

 🌟 8.1 代码

class Solution {
    public int i;
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return buildTreeChild(preorder,inorder,0,inorder.length-1);
    }
    public TreeNode buildTreeChild(int[] preorder, int[] inorder,int start,int end) {
        //当end>start时说明当前节点已无左右子树，返回
        if (start > end) {
            return null;
        }
        int rootVal = preorder[i];
        i++;
        TreeNode node = new TreeNode(rootVal);
        //找到中序遍历序列中根节点的下标
        int rootIndex = findRoot(rootVal,inorder);
        //前序遍历，根左右，应先递归左子树
        node.left = buildTreeChild(preorder,inorder,start,rootIndex-1);
        node.right = buildTreeChild(preorder,inorder,rootIndex+1,end);
        return node;
    }
    private int findRoot(int rootVal, int[] inorder) {
        for (int j = 0; j < inorder.length; j++) {
            if (inorder[j] == rootVal) {
                return j;
            }
        }
        return -1;
    }
}

 💎  9、题九：根据后序和中序遍历序列构建二叉树

 . - 力扣（LeetCode）

  🌟 9.1 思路分析

本题和题八的思想是基本一致的，通过后序遍历序列来确定根节点，通过中序序列找到当前根节点来确定左右子树。

  • 唯一需要注意的是，本题确定根节点的序列是后序序列，左右根的顺序，所以后序遍历序列最后的位置是整体树的根，而次后位置是其右子树的根，然后是右子树的右子树的根....。
  • 当然左右子树可能为空，但是再根据中序遍历的序列就可以确定具体树的结构。
  • 所以应该先递归创建右子树，再递归创建左子树。 

   🌟 9.2 代码

class Solution {
    public int i;
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        this.i = postorder.length-1;
        return buildTreeChild(postorder,inorder,0,inorder.length-1);
    }
    public TreeNode buildTreeChild(int[] postorder, int[] inorder,int start,int end) {
        if (start > end) {
            return null;
        }
        int rootVal = postorder[i];
        i--;
        TreeNode node = new TreeNode(rootVal);
        int rootIndex = findRoot(rootVal,inorder);
        //先递归创建右子树 再递归创建左子树
        node.right = buildTreeChild(postorder,inorder,rootIndex+1,end);
        node.left = buildTreeChild(postorder,inorder,start,rootIndex-1);

        return node;
    }

    private int findRoot(int rootVal, int[] inorder) {
        for (int j = 0; j < inorder.length; j++) {
            if (inorder[j] == rootVal) {
                return j;
            }
        }
        return -1;
    }
}

Geboren zur Sonne
关注
  • 42
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
leetcode338-leetcode-java:力扣Java解决方案
07-01
leetcode-java LeetCode Java Solution 题目 ： ： ： ： more ： ： ： ： ： ： more ： ： ： 题解 recursion 104题解 解法：递归 复杂度：O(n)、O(h) class Solution { public int maxDepth(TreeNode root) { //...
leetcode和oj-leetcode-java:力扣在线裁判解决方案
06-30
Java 版 Leetcode 问题分类 细绳 8 字符串到整数 (atoi) 14 最长公共前缀20 个有效括号28 实现 strStr() 43 乘法字符串 二分查找 列表/链表 19 从列表末尾删除第 N 个节点21 合并两个排序列表24个交换节点对27 删除...
数据结构（Java）：力扣&牛客 二叉树面试OJ题（一）
2401_83595513的博客
07-15 1465
二叉树面试OJ题（part1）
数据结构java版之二叉树（部分offer面试题篇）
weixin_58850105的博客
01-22 1618
目录 一、二叉树的基本操作 1.获取树中节点的个数 2.获取叶子节点的个数 3.子问题思路-求叶子结点个数 4.获取第K层节点的个数 5.获取二叉树的高度 6.检测值为value的元素是否存在 7.判断一棵树是不是完全二叉树 二、二叉树相关oj题 1. 检查两颗树是否相同 2. 另一颗树的子树 3. 二叉树最大深度 4. 判断一颗二叉树是否是平衡二叉树 5. 对称二叉树 6. 二叉树的构建及遍历 7. 二叉树的分层遍历 8. 给定一个二叉树, 找到该树中两个指定节点的最..
Java【数据结构入门OJ题33道】——力扣刷题记录1
yzhcjl_的博客
03-09 763
记录力扣数据结构入门OJ题33道。
数据结构第十讲：二叉树OJ题
2301_79761834的博客
08-04 777
数据结构第十讲：二叉树OJ题
数据结构进阶 二叉树OJ题一
小萌新的博客
12-30 668
几道二叉树oj题
数据结构进阶 二叉树OJ题二
小萌新的博客
12-31 444
几道二叉树oj题
Java力扣刷题——二叉树oj题整理
m0_57180439的博客
01-20 850
二叉树oj题
【数据结构】——二叉树oj题详解
weixin_62678196的博客
09-01 806
二叉树的OJ题详解
数据结构刷题篇 之 【力扣二叉树基础OJ】详细讲解（含每道题链接及递归图解）
foodsx的博客
03-29 1057
数据结构刷题篇 之 【力扣二叉树基础OJ】详细讲解（含每道题链接及递归图解）
leetcode砖墙-LeetCode_java:力扣_java
07-01
LeetCode_java 在家也是无聊，想着每天把刷题的感悟记录下来（这样之后也不用再总结了！ 51.N皇后 372.超级次方 452.用最少数量的箭引爆气球 456.132模式 474.一和零 494.目标和 496.提莫攻击 498.对角线遍历 522....
数据结构，力扣算法题.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
力扣面试经典150题力扣面试经典150题
11-21
"力扣面试经典150题"是一系列精选的题目，旨在帮助面试者熟悉常见的面试问题，提升解决问题的能力。 在LeetCode中，面试经典150题主要分为以下几个类别： 1. **数组**：数组是最基础的数据结构，涉及到的问题包括...
C语言 | Leetcode C语言题解之第337题打家劫舍III
最新发布
m0_59237910的博客
08-15 189
C语言 | Leetcode C语言题解之第337题打家劫舍III
【长度最小的子数组】python刷题记录
m0_73629042的博客
08-12 227
【代码】【长度最小的子数组】python刷题记录。
Java | Leetcode Java题解之第337题打家劫舍III
m0_57195758的博客
08-15 282
Java | Leetcode Java题解之第337题打家劫舍III
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 219
C++ | Leetcode C++题解之第337题打家劫舍III
算法题：力扣上的165题
05-04
题目描述： 给你两个版本号 version1 和 version2 ，请你比较它们。 版本号由一个或多个修订号组成，各修订号由一个 '.' 连接。每个修订号由多位数字组成，可能包含前导零。每个版本号至少包含一个字符。修订号从左到右编号，下标从0开始，最左边的修订号下标为0 ，下一个修订号下标为1，以此类推。例如，2.5.33 和 0.1 都是有效的版本号。 比较版本号时，请按从左到右的顺序依次比较它们的修订号。比较修订号时，只需比较忽略任何前导零后的整数值。也就是说，修订号1和修订号001相等。如果版本号没有指定某个下标处的修订号，则该修订号视为0。例如，版本1.0 小于版本1.1，因为它们下标为0的修订号相同，而下标为1的修订号分别为0和1，0 < 1。 返回规则如下： 如果 version1 > version2 返回 1， 如果 version1 < version2 返回 -1， 否则返回 0。 示例 1： 输入：version1 = "1.01", version2 = "1.001" 输出：0 解释：忽略前导零，"01" 和 "001" 都表示相同的整数 "1" 示例 2： 输入：version1 = "1.0", version2 = "1.0.0" 输出：0 解释：version1 没有指定下标为 2 的修订号，即视为 "0" 示例 3： 输入：version1 = "0.1", version2 = "1.1" 输出：-1 解释：version1 中下标为 0 的修订号是 0，version2 中下标为 0 的修订号是 1 。0 < 1，所以 version1 < version2 示例 4： 输入：version1 = "1.0.1", version2 = "1" 输出：1 示例 5： 输入：version1 = "7.5.2.4", version2 = "7.5.3" 输出：-1 提示： 1 <= version1.length, version2.length <= 500 version1 和 version2 仅包含数字和 '.' version1 和 version2 都是 有效版本号
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值