重刷leedcode（11-20）

最新推荐文章于 2023-12-04 15:53:16 发布
最新推荐文章于 2023-12-04 15:53:16 发布
阅读量99 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41063141/article/details/103091775
版权

重刷leedcode（11-20）

11.盛最多水的容器

在这里插入图片描述
分析
解题思路是用双指针去遍历数组，height小的指针进行移动。如果是左右指针的height相等的情况，那么双指针就同时移动。

class Solution {
    public int maxArea(int[] height) {
        if(height==null||height.length<2) return 0;
        int area=0;
        int left=0;
        int right=height.length-1;
        while(left<right){
            area=Math.max(area,Math.min(height[left],height[right])*(right-left));
            if(height[left]<height[right]) left++;
            else if(height[left]>height[right]) right--;
            else {left++;right--;}
        }
        return area;
    }
}

12.整数转罗马数字

在这里插入图片描述
ps
这题的思路就是用贪心算法来做。技巧就是num/arb[index]得到最高位。num % arb[index]得到除最高位后的数

class Solution {
    public String intToRoman(int num) {
        StringBuilder sb=new StringBuilder();
        String[] roman={"M","CM","D","CD","C", "XC", "L", "XL" , "X",   "IX", "V","IV","I"};
        int[] alb=     {1000,900,500,400,100,90,50,40,10,9,5,4,1};
        int index=0;
        int count=0;
        while(num>0){
           count= num/alb[index];
           while(count-- > 0){
              sb.append(roman[index]);
           }
           num=num % alb[index];
           index++;
        }
        return sb.toString();
    }
}

13.罗马数字转整数

ps
这题主要就是用到了Map和string.substring(startIndex,endIndex)来实现的

class Solution {
    public int romanToInt(String s) {
        int result=0;
          Map<String,Integer>map=new HashMap<>();
          map.put("M",1000);
          map.put("CM",900);
          map.put("D",500);
          map.put("CD",400);
          map.put("C",100);
          map.put("XC",90);
          map.put("L",50);
          map.put("XL",40);
          map.put("X",10);
          map.put("IX",9);
          map.put("V",5);
          map.put("IV",4);
          map.put("I",1);

          for(int i=0;i<s.length();){
              //substring(startIndex,endIndex){从下标startIndex到endIndex下标的结束}
                if(i+1<s.length()&&map.containsKey(s.substring(i,i+2))){
                   result+= map.get(s.substring(i,i+2));
                   i+=2;
                }
                else{
                     result+= map.get(s.substring(i,i+1));
                    i++;
                }
          }
          return result;
    }
}

14. 最长公共前缀

ps
string.indexOf(String x){//查找字符x在string中首次出现的索引值} 找到则返回索引，没找到则返回-1

class Solution {
   public String longestCommonPrefix(String[] strs) {
       if(strs.length==0) return "";
       String prefixStr=strs[0];
       for(String s:strs){
           //indexOf()
           //只要前缀不是s字符串的子串就一直循环
           while(s.indexOf(prefixStr)!=0){
               //["abc","ab","a"]  如果是abc和abc，则不会进循环，因为前缀abc是abc的字串
               //abc和ab会进循环，因为前缀abc不是ab的字串。
               prefixStr=prefixStr.substring(0,prefixStr.length()-1);
              // if(prefixStr=="") return "";
           }
       }
       return prefixStr;
   }
}

15.三数之和

在这里插入图片描述
ps
排序+三指针（基指针+左指针+右指针）
左指针=基指针+1；
然后再考虑一下：以下几种特殊情况的处理

  • 如果 nums[i]nums[i]大于 00，则三数之和必然无法等于 00，结束循环
  • 如果 nums[i]nums[i] == nums[i-1]nums[i−1]，则说明该数字重复，会导致结果重复，所以应该跳过
  • 当 sumsum == 00 时，nums[L]nums[L] == nums[L+1]nums[L+1] 则会导致结果重复，应该跳过，L++L++
  • 当 sumsum == 00 时，nums[R]nums[R] == nums[R-1]nums[R−1] 则会导致结果重复，应该跳过，R–R−−

作者：guanpengchn
链接：https://leetcode-cn.com/problems/3sum/solution/hua-jie-suan-fa-15-san-shu-zhi-he-by-guanpengchn/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>>result=new ArrayList<>();  
        int len=nums.length;      
        if(nums==null&&len<3) return result;
        int left=0;
        int right=len-1;    
        //排序时间复杂度是nlogn
        Arrays.sort(nums);
         int temp=0;
         int sum=0;
        for(int i=0;i<len;i++){
            if(nums[i]>0) break;
            //满足条件就不执行下面的的代码，直接进入下一轮循环。
            if(i>0&&nums[i]==nums[i-1]) continue;
             left=i+1;
                right=len-1;
            while(left<right){
               
                 sum=nums[i]+nums[left]+nums[right];
                if(sum==0) {
                   result.add(Arrays.asList(nums[i],nums[left],nums[right]));
                    while(left<right&&nums[right]==nums[right-1]) right--;
                while(left<right&&nums[left]==nums[left+1]) left++;
                   left++;right--;
                }
                else if(sum<0) left++;
                else right--;
            }
        }
        return result;
    }
}

16. 最接近的三数之和

在这里插入图片描述
ps
这里的关键点就是：使用Maths.abs()计算绝对值，如果当前的绝对值小于之前的绝对值，那么就更新绝对值。

class Solution {
    public int threeSumClosest(int[] nums, int target) {
        int L=0;
        int R=0;
        int len=nums.length;
        int tempResult=Integer.MAX_VALUE;
        int result=0;
        if(nums==null&&len<3) return Integer.MIN_VALUE;
        int sum=0;
        int abs=0;
        Arrays.sort(nums);
        //这里i是基base指针，所以i<len-2;
        for(int i=0;i<len-2;i++){
              L=i+1;
              R=len-1;
              while(L<R){
                 sum=nums[L]+nums[R]+nums[i];
                 abs=Math.abs(sum-target);
                 if(abs==0) return sum; 
                 if(abs<tempResult){
                     tempResult=abs;
                     result=sum;
                 }
                 //先排序是一个值偏大造成的，剩下就可以只讨论值偏小造成的这种可能了。
                 //这里不能写成if(abs>target){}
                 if(sum>target) R--;
                 else L++; 
              }
        }
        return result;
    }
}

17. 电话号码的字母组合

在这里插入图片描述
ps
主要用到了substring（int startIndex）方法去遍历字符串：例如happy，for(){“happy”.substring(1);“happy”.substring(0,1);},那么在每轮循环中字符变为：appy—>ppy–>py–>y—>length==0.我们获取到的字母依次是 a，p，p，y

class Solution {
    //这里需要重写实现添加，使其map为类属性，不能在函数里面实现map的put
     Map<String,String>map=new HashMap<String,String>(){{
        put("2","abc");
        put("3","def");
        put("4","ghi");
        put("5","jkl");
        put("6","mno");
        put("7","pqrs");
        put("8","tuv");
        put("9","wxyz");
     }};
        List<String>result=new ArrayList<String>();

    public List<String> letterCombinations(String digits) {
        //注意这里判空时要用digits.length()==0，不能使用digits==""来判断。
        if(digits.length()==0||digits==null) return result;
        backtrack("",digits);
         return result;
    }
        //回溯法
        //1. 函数有两个参数：一个参数值在不断增加，一个参数值在不断减少（一般不断减少的那个参数值常常作为每轮回溯的总结条件）
        //2. 终结条件+递推条件（回溯法可以看作是暴力枚举的改良升级版）
        //3. 虽然计算机在处理回溯时时层层跳出来执行的，但是编写回溯法时，站在层层深入的角度去编写递推条件---终结条件时跳出逻辑，一般在循环体的第一句就开始判断，在每次跳入之前就判断一次是否可以跳出。
        //可将回溯看作是暴力穷举法的改良升级版
       public void backtrack(String strAdd,String strRemv){
           //如果走到最底层了，那么for循环的每个值都会进入该分支口，通过该口跳出递归
           //如果没有走到最底层，则继续进入下一层，继续递归
          if(strRemv.length()==0){ result.add(strAdd);}
          else{ 
          String record= strRemv.substring(0,1);
          String temp=map.get(record);
          for(int i=0;i<temp.length();i++){
               
               String letter=temp.substring(i,i+1);
               //这里用递归掩盖一重循环。这重循环是一套组合拳来实现的。for(){}+backstrack(s.substring(1))+s.substring(0,1)+s.substring(i,i+1);
               //可理解成ad,ae,af,而不是adaeaf
                backtrack(strAdd+letter,strRemv.substring(1));
          }
          }
       }
}

18. 四数之和

在这里插入图片描述
ps
参考这位大神的思路写的。我写出来代码执行效率低了一点。可以参照大神的进行代码优化
力扣题解

写一下算法执行的思路：

  • 总体思路：求四数之和。自然想到用4个指针。为了简化思考，可以先假定：固定前两个指针，然后后两个指针按照二分查找的代码框架进行编码。然后再回来二重遍历固定的两个指针
  1. 遍历i----->简化思维：先把 i 固定 （根据题目要求，每轮开始循环前，注意 i 的去重）
  2. 遍历j----->再把 j 固定 （每轮开始循环前，注意 j 的去重，同时注意 j 的初始位置的调整。每轮还要重新调整 L ，R 左右指针的初始位置）
  3. 按照二分法的思想移动左右指针（同时注意左右指针的去重）

在这里插入图片描述

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>>result=new ArrayList<>();
        if(nums==null||nums.length<4) return result;
        int i=0,j=0,L=0,R=0;
        Arrays.sort(nums);
        int len=nums.length;
        for(;i<len-3;i++){
            if(i>0&&nums[i]==nums[i-1]) continue;
            for(j=i+1;j<len-2;j++){
                if(j>i+1&&nums[j]==nums[j-1]) continue;
                 L=j+1;
                 R=len-1;
                 while(L<R){
                    int sum=nums[i]+nums[j]+nums[L]+nums[R];
                    if(sum==target){
                        result.add(Arrays.asList(nums[i],nums[j],nums[L],nums[R]));
                        ++L;
                        --R;
                         while(R<len-2&&nums[R]==nums[R+1]) R--;
                         while(L<len-1&&nums[L]==nums[L-1]) L++;
                    } 
                    else if(sum>target) {
                         R--;
                         while(R<len-2&&nums[R]==nums[R+1]) R--;
                         }
                    else{
                        L++;
                        while(L<len-1&&nums[L]==nums[L-1]) L++;
                        }
                 }                 
            }
        }
        return result;
    }
}

19. 删除链表的倒数第N个节点

在这里插入图片描述
ps
用双指针就能实现一趟遍历完成
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //先构造一个哑节点（虚拟节点）
        ListNode temp=new ListNode(0);
        temp.next=head;
        ListNode slow=temp;
        ListNode fast=temp;
        //我写的是i<n-1，但是这样（ slow=slow.next;）总是会出现null空指针
        //官方题解的解决办法是用n+1
        for(int i=0;i<n+1;i++){
            fast=fast.next;
        }
        while(fast!=null){
             fast=fast.next;
             slow=slow.next;
        }
        slow.next=slow.next.next;
        return temp.next;
    }
}

20. 有效的括号

在这里插入图片描述
ps
用到了栈的知识

class Solution {
    Map<Character,Integer>map=new HashMap<Character,Integer>(){{
    //官方处理是put('[',']')
    //这样在下文就可以使用map.get(stack.pop())==c来判断，可以减少hash查找次数
        put('(',1);
        put(')',1);
        put('[',2);
        put(']',2);
        put('{',3);
        put('}',3);
    }};
    public boolean isValid(String s) {
        if(s==null&&s.length()==0) return true;
        Stack<Character> stack=new Stack<>();
        char[] cs=s.toCharArray();
        for(char c:cs){
           if(c=='('||c=='{'||c=='[') stack.push(c);
           //if(c==')'||c=='}'||c==']'){
            else{
              if(!stack.empty()&& map.get(stack.pop())==map.get(c)) continue;
              else return false;
           } 
        }
        if(stack.empty()) return true;
        else return false;
        }
}
千篇不一律
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode-How-What 力扣Leetcode刷题指南
edwardwjz的博客
03-05 2570
Leetcode-How-What 力扣Leetcode刷题指南 About the way how to use Leetcode wisely for preparing the interview and the solutions to some Leetcode problems’. 怎样为准备面试机智聪明的刷题（高效刷题）以及一些题目的题解。 同 github 链接： https:/...
leetcode 实战篇-字符串
qq_51387669的博客
10-15 433
前言 哈喽大家好，我是雨墨，小老弟又来了，这是小老弟的第二篇博客，记录小老弟我刷字符串类型的leetcode 题目的笔记。每日更新3道，直至完成目标~ 话不多说，咱们开始正题~~ leetcode 实战篇-字符串 leetcode 344 反转字符串（开胃菜） 题目链接 传送门：https://leetcode-cn.com/problems/reverse-string/ 我的题解 题目描述 编写一个函数，将字符串反转过来，要求必须原地修改字符串。 样例 输入：s = ["h","e","l","l","
重刷leetcode
qigezuishuaide的博客
10-02 294
我打算按照下面的方式重新刷题，毕竟经常出现刷了一段时间就忘了。 代码我也打算重新写，并更新代码的完成情况。其它基础知识还没想好怎么处理，毕竟我虽然干了快三年，但是并没有学到啥东西，果然海康的产品开发就是测试和技术支持，layman都能干。 1.两数之和：哈希表 ...
leetcode刷题 - SQL - 中等、困难
qq_58551342的博客
11-10 455
如果不能平均分配，则较小桶号的桶分配额外的行，并且各个桶中能放的数据条数最多相差1。聚合函数对一组值执行计算并返回单一的值，如sum()，count()，max()，min()， avg()等。到指定的数量n的桶中,将桶号分配给每一行，排序对应的数字为桶号，序号从1到n。，表示跳过开头的n行，返回接下来的m条数据。想知道各个地区的前几名、各个班的前几名。表中第二高的薪水。如果不存在第二高的薪水，查询应该返回。第三题提供的思路，但是无法实现重复的最大值。如果有两个人都排在第3名，则没有第4名。
python-od-leetcode-80道必刷题
最新发布
m0_45325327的博客
12-04 111
2.动态规划-斐波那契数.py3.动态规划-爬楼梯.py4.动态规划-使用最小花费爬楼梯.py5.动态规划-不同路径.py6.动态规划-不同路径 II.py7.动态规划-整数拆分.py8.动态规划-不同的二叉搜索树.py9.动态规划-0-1背包为问题.py10.动态规划-0-1背包-滚动数组优化.py11.动态规划之背包问-分割等和子集.py。
LeetCode 700题 题解答案集合 Python
热门推荐
Keep Coding
03-27 10万+
2019.5.12更新至题号796，目前共有265题。 2019.5.26更新至题号72， 目前共有347题。 2019.6.16更新至题号70，目前共有382题。 2019.7.7更新至题号5120，目前共有442题。 2019.8.5更新至题号1147，目前共有502题。 2019.9.6更新至题号288， 目前共有551题。 2019.11.13更新至题号426，目前共有602题...
LeetCode解题汇总目录
Michael是个半路程序员
09-06 7万+
此篇为学习完《数据结构与算法之美》后，在LeetCode刷题的汇总目录，方便大家查找（Ctrl+Find），一起刷题，一起PK交流！如果本文对你有帮助，可以给我点赞加油！ Updated on 2022.6.12刷题可以按照不同的专题进行，便于加强某个知识点的理解。另有《剑指Offer》面试题（更新完毕）、《程序员面试金典》面试题（更新完毕）、LintCode代码能力测试CAT。LeetCode MySQL 数据库解题目录点击访问 我的 LeetCode 主页我的 GitHub 主页注：本文超过字数限制，
【代码随想录】【LeetCode】自学笔记 11 - 动态规划
qdsn的博客
04-03 5338
动态规划简称DP，如果某一问题有很多重叠子问题，使用动态规划是最有效的。
「刷leetcode题」数组
雨y飘零久的博客
09-12 374
文章目录1 两个数之和(2020.09.12) 1 两个数之和(2020.09.12) 1 自己解法: 思路主要是双循环来一个一个试. /** * @param {number[]} nums * @param {number} target * @return {number[]} */ var twoSum = function(nums, target) { let res = [] for(let i = 0; i<nums.length; i++){
产品经理刷leetcode-interview:面试
06-30
产品经理刷leetcode 目录 C/C++ const // 类 class A { private: const int a; // 常对象成员，只能在初始化列表赋值 public: // 构造函数 A() { }; A(int x) : a(x) { }; // 初始化列表 // const可用于对重载函数的...
萌新刷leetcode题-leetcode-with-js:用JavaScript来刷leetcode
06-30
leetcode-with-js 前端萌新尝试用 JavaScript 来刷 leetcode 如有不对，大佬们多多指教～ 另： 在我的个人博客上会更新一些其他前端学习与工作上遇到的事情，欢迎访问，地址： 该仓库内容会在我的个人博客 LeetCode ...
leetcode中国-leetcode-rust-cn:用Rust刷LeetCode，带中文注释
06-29
leetcode-rust-cn LeetCode solutions in Rust, with Chinese comment. 用 Rust 刷 LeetCode，带中文注释 VSCode 插件 ，插件用法见其 插件 插件 切换到 LeetCode 英文版，然后通过第三方帐号(如 GitHub)登录 用法：...
leetcode题库-leetcode-helper:leetcode助手
06-29
LeetCode-cn AC 的题目描述和提交的代码，并整理至相应的文件夹，生成相应的 README 文件。 本项目参考了: 特点 支持爬取题目列表（中英文），保存为指定目录下的 README 和 README_EN 文件 支持爬取题目描述（中...
leetcode11-leetCode:leetcode
07-01
leetcode11 leetCode leetCode3 无重复字符的最长子串 滑动窗口，遇到相同的窗口大小调整 leetCode4 寻找两个正序数组的中位数 合并两个链表 分区法 分成左右两边相等区域 leetCode5 最长回文子串 1 中心扩散法， ...
动态规划算法解01背包问题（思路及算法实现）
远行的博客
05-13 7万+
说明：算法源自教材。本文相当于对教材做的一个笔记(动态规划与贪心算法解01背包必须先对背包按照单位重量的价格从大到小排序，否则拆分的子问题就不具备最优子结构的性质) 动态规划算法： 动态规划就是一个填表的过程。该表记录了已解决的子问题的答案。求解下一个子问题时会用到上一个子问题的答案。{比如01背包问题：假如有1个背包，背包容量是10，有5个物品，编号为1，2，3，4，5，他们都有各自的...
eclipse CDT报错解决方案：Error: Program "make" not found in PATH
远行的博客
05-17 2万+
eclipse cdt Program "make" not found in PATH 1. 2. 3. 4. 5. 6.
回溯法解01背包问题
远行的博客
05-18 2万+
概念： 回溯法采用深搜+剪枝来搜索生成树： 步骤： 1. 假设规定左叉标1（代表选择该物品装入背包），右叉标0（代表不选择该物品装入背包）。给定示例输入： 背包容量c=10 物品个数n=5 物品重量w={2，2，6，5，4} 物品价格p={6，3，5，4，6} 注意： 左子树的解的上界与父节点相同，不用计算。右子树的解的界值：较好的就算方法是将剩余物品依其单位重量价...
贪心算法解背包问题
远行的博客
05-19 2万+
辨析： 背包问题能用贪心算法求解，但是01背包问题不能用贪心算法求解(因为01背包问题不具备贪心选择性质----通过局部最优，达不到全局最优) 举个例子：背包容量=50； w[]={10,20,30} ,p[]={60,100,120} 用贪心选择（10+20）<50，p=160，但这并不是最优解，事实上(20+30)=50,p=100+120=220.才是问题的...
idea leetcode-edito乱码
09-01
LeetCode-Editor是一种在线编码工具，它提供了一个用户友好的界面编写和运行代码。在使用LeetCode-Editor时，有时候会出现乱码的问题。 乱码的原因可能是由于编码格式不兼容或者编码错误导致的。在这种情况下，我们可以尝试以下几种解决方法： 1. 检查文件编码格式：首先，我们可以检查所编辑的文件的编码格式。通常来说，常用的编码格式有UTF-8和ASCII等。我们可以将编码格式更改为正确的格式。在LeetCode-Editor中，可以通过界面设置或编辑器设置来更改编码格式。 2. 使用正确的字符集：如果乱码是由于使用了不同的字符集导致的，我们可以尝试更改使用正确的字符集。常见的字符集如Unicode或者UTF-8等。在LeetCode-Editor中，可以在编辑器中选择正确的字符集。 3. 使用合适的编辑器：有时候，乱码问题可能与LeetCode-Editor自身相关。我们可以尝试使用其他编码工具，如Text Editor、Sublime Text或者IDE，看是否能够解决乱码问题。 4. 查找特殊字符：如果乱码问题只出现在某些特殊字符上，我们可以尝试找到并替换这些字符。通过仔细检查代码，我们可以找到导致乱码的特定字符，并进行修正或替换。 总之，解决LeetCode-Editor乱码问题的方法有很多。根据具体情况，我们可以尝试更改文件编码格式、使用正确的字符集、更换编辑器或者查找并替换特殊字符等方法来解决这个问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值