leetcode练习（简单总结做过的题）

蔚落 2022-11-27 05:26 96阅读 0赞

### 文章目录 ###

*  leetcode（简单总结做过的题）
 *   *   *  两数之和：\`简单\`
         *  整数反转：\`简单\`
         *  回文数：\`简单\`
         *  罗马数字转整数：\`简单\`
         *  最长公共前缀：\`简单\`
         *  有效的括号：\`简单\`
         *  合并两个有序的链表：\`简单\`
         *  删除排序数组中的重复项：\`简单\`
         *  移除元素：\`简单\`
         *  实现strStr()函数：\`简单\`
         *  搜索插入位置：\`简单\`
         *  两数相加：\`中等\`
         *  无重复字符的最长字串：\`中等\`

# leetcode（简单总结做过的题） #

题目来源：[力扣（LeetCode）][LeetCode]

### 两数之和：`简单` ###

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9
    
    因为 nums[0] + nums[1] = 2 + 7 = 9
    
    所以返回 [0, 1]

题解：

class Solution { 
        public int[] twoSum(int[] nums, int target) { 
            Map<Integer,Integer> map = new HashMap<>();
            for(int i=0;i<nums.length;i++){ 
                int temp = target - nums[i];
                if(map.containsKey(temp)){ //nums的第一个值会存入map 
                    return new int[]{ map.get(temp),i};//将两个索引值返回
                }
                map.put(nums[i],i); //将数与索引值一起存入map
            }
            return new int[]{ -1,-1};
        }
    }    
    
        // for(int i=0;i<nums.length;i++){ 
        // for(int j=i+1;j<nums.length;j++){ 
        // if(nums[i]==target-nums[j]){ 
        // return new int[]{i,j};
        // }
        // }
        // }
        // throw new IllegalArgumentException("No two sum solution");
        // }

### 整数反转：`简单` ###

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:

输入: 123  
输出: 321  
示例 2:

输入: -123  
输出: -321  
示例 3:

输入: 120  
输出: 21  
注意:

假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 \[−231, 231 − 1\]。请根据这个假设，如果反转后整数溢出那么就返回 0。

题解：

class Solution { 
        public int reverse(int x) { 
            long y=0;
            while(x != 0){ 
                y = x%10 + y*10;
                x=x/10;
            }
            return (int)y==y?(int)y:0;//要考虑是否溢出
        }
    }

### 回文数：`简单` ###

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例 1:

输入: 121  
输出: true  
示例 2:

输入: -121  
输出: false  
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。  
示例 3:

输入: 10  
输出: false  
解释: 从右向左读, 为 01 。因此它不是一个回文数。  
进阶:

你能不将整数转为字符串来解决这个问题吗？

题解：（1）

class Solution { 
        public boolean isPalindrome(int x) { 
            if(x<0){ 
                return false;
            }
            String s = Integer.toString(x); //转换成字符串
            String sf =new StringBuilder(s).reverse().toString(); //将字符串反转
            if(sf.equals(s)){ 
                return true;
            }
            return false;
        }
    }

题解：（2）

class Solution { 
        public boolean isPalindrome(int x) { 
            if (x < 0 || (x % 10 == 0 && x != 0)) {  //当x为负数或x为10的倍数时，x不是回文数
                return false;
            }
    
            int revertedNumber = 0;
            while (x > revertedNumber) { 
                revertedNumber = revertedNumber * 10 + x % 10;
                x /= 10;
            }
          
         //当x是偶数位时，x==revertedNumber，例如1221；当x是奇数位时，x == revertedNumber / 10，例如121
            return x == revertedNumber || x == revertedNumber / 10;
        }
    }

### 罗马数字转整数：`简单` ###

罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符 数值  
I 1  
V 5  
X 10  
L 50  
C 100  
D 500  
M 1000  
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。  
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。  
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。  
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

示例 1:

输入: “III”  
输出: 3  
示例 2:

输入: “IV”  
输出: 4  
示例 3:

输入: “IX”  
输出: 9  
示例 4:

输入: “LVIII”  
输出: 58  
解释: L = 50, V= 5, III = 3.  
示例 5:

输入: “MCMXCIV”  
输出: 1994  
解释: M = 1000, CM = 900, XC = 90, IV = 4.

题解：

class Solution { 
        public int romanToInt(String s) { 
            int sum=0;
            int pre = getValue(s.charAt(0));
            for(int i=1;i<s.length();i++){ 
                int back = getValue(s.charAt(i));
                if(pre < back){  //小于情况例如：IV，则需要减去I
                    sum-=pre;
                }else{ 
                    sum+=pre;  //III
                }
                pre = back;
            }
            sum+=pre;
            return sum;
        }
        private int getValue(char c){ 
            switch(c){ 
                case 'I': return 1;
                case 'V': return 5;
                case 'X': return 10;
                case 'L': return 50;
                case 'C': return 100;
                case 'D': return 500;
                case 'M': return 1000;
                default: return 0;
            }
        }
    }

### 最长公共前缀：`简单` ###

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例 1:

输入: \[“flower”,“flow”,“flight”\]  
输出: “fl”  
示例 2:

输入: \[“dog”,“racecar”,“car”\]  
输出: “”  
解释: 输入不存在公共前缀。  
说明:

所有输入只包含小写字母 a-z 。

题解：

class Solution { 
        public String longestCommonPrefix(String[] strs) { 
            if(strs == null || strs.length == 0){  //若为空则返回空字符串
                return "";
            }
            String prefix = strs[0];
            for(int i=1;i<strs.length;++i){ 
                prefix = CompareStrings(prefix,strs[i]);
                if(prefix.length() == 0){ 
                    break;//只要其中两个没有公共的，则退出循环
                }
            }
            return prefix;
        }
    
        private String CompareStrings(String a,String b){ 
            int len = Math.min(a.length(),b.length());//取短的那个字符串的长度
            int i=0;
            while(i<len && a.charAt(i)==b.charAt(i)){  //比较两个字符串的字符
                i++;
            }
            return a.substring(0,i);//截取公共前缀
        }
    }

### 有效的括号：`简单` ###

给定一个只包括 ‘(’，’)’，’\{’，’\}’，’\[’，’\]’ 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。  
左括号必须以正确的顺序闭合。  
注意空字符串可被认为是有效字符串。

示例 1:

输入: “()”  
输出: true  
示例 2:

输入: “()\[\]\{\}”  
输出: true  
示例 3:

输入: “(\]”  
输出: false  
示例 4:

输入: “(\[)\]”  
输出: false  
示例 5:

输入: “\{\[\]\}”  
输出: true

题解：

class Solution { 
        private Map<Character,Character> map;
    
        public Solution(){  //初始化map
            this.map = new HashMap<Character,Character>();
            this.map.put(')','(');
            this.map.put(']','[');
            this.map.put('}','{');
        }
    
        public boolean isValid(String s) { 
            if(s.length() % 2 != 0){ 
                return false;
            }
    
            Stack<Character> stack = new Stack<Character>();//new一个字符串栈（先进后出）
            for(int i=0;i<s.length();i++){ 
                char c = s.charAt(i);
                
                if(this.map.containsKey(c)){  // ( {不是key，所以进栈 } )是key，所以进行下一步
    
                    char ck = stack.empty() ? '#':stack.pop();//按顺序出栈 { (
                    if(ck != this.map.get(c)){  //若不匹配则为false
                        return false;
                    }
                }else{ 
                    stack.push(c); // ( { 
                }
            }
            return stack.isEmpty();
        }
    }

### 合并两个有序的链表：`简单` ###

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：

输入：1->2->4, 1->3->4  
输出：1->1->2->3->4->4

题解：

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next = next; } * } */
    class Solution { 
        public ListNode mergeTwoLists(ListNode l1, ListNode l2) { 
            ListNode p=l1,q=l2;
            if(p==null){ 
                return q;
            }
            if(q==null){ 
                return p;
            }
            if(p.val < q.val){ 
                p.next = mergeTwoLists(p.next,q);  //递归思想，一开始没想到！
                return p;
            }else{ 
                q.next = mergeTwoLists(p,q.next);
                return q;
            }
        }
    }

### 删除排序数组中的重复项：`简单` ###

给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

示例 1:

给定数组 nums = \[1,1,2\],

函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。

你不需要考虑数组中超出新长度后面的元素。  
示例 2:

给定 nums = \[0,0,1,1,1,2,2,3,3,4\],

函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。

你不需要考虑数组中超出新长度后面的元素。

题解：

class Solution { 
        public int removeDuplicates(int[] nums) { 
            if(nums.length == 0){ 
                return 0;
            }
            int len=0;
            for(int i=1;i<nums.length;i++){ 
                if(nums[i] != nums[len]){  //只有不相等的时候才把后面的元素一一放到指定的下一个位置
                    len++;
                    nums[len]=nums[i];
                }
            }
            return len+1;
        }
    }

### 移除元素：`简单` ###

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1:

给定 nums = \[3,2,2,3\], val = 3,

函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。

你不需要考虑数组中超出新长度后面的元素。  
示例 2:

给定 nums = \[0,1,2,2,3,0,4,2\], val = 2,

函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

注意这五个元素可为任意顺序。

你不需要考虑数组中超出新长度后面的元素。

题解：

class Solution { 
        public int removeElement(int[] nums, int val) { 
            int len = 0;
            for(int i=0;i<nums.length;++i){ 
                if(nums[i] != val){ 
                    nums[len] = nums[i];  //跟上一题的思路相同
                    len++;
                }
            }
            return len;
        }
    }

### 实现strStr()函数：`简单` ###

实现 strStr() 函数。

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。

示例 1:

输入: haystack = “hello”, needle = “ll”  
输出: 2  
示例 2:

输入: haystack = “aaaaa”, needle = “bba”  
输出: -1  
说明:

当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。

对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。

题解：（1）

class Solution { 
        public int strStr(String haystack, String needle) { 
            int len1 = haystack.length(),len2 = needle.length();
            for(int i=0;i<len1-len2+1;i++){ 
                if(haystack.substring(i,i+len2).equals(needle)){  //通过截取字符串来比较substring
                    return i;
                }
            }
            return -1;
        }
    }

题解：（2）

class Solution { 
        public int strStr(String haystack, String needle) { 
            int len1 = haystack.length(),len2 = needle.length();
            if(len2 == 0){ 
                return 0;
            }
            for(int i=0;i<len1-len2+1;i++){ 
                if(haystack.charAt(i) == needle.charAt(0)){ 
                    if(haystack.substring(i,i+len2).equals(needle)){ 
                        return i;
                    }
                }
            }
            return -1; 
        }
    }
    
    //参考的javascript解法：(见下)
    var strStr = function (haystack, needle) { 
        if (needle === "") return 0
        for (var i = 0; i < haystack.length; i++) { 
            if (haystack[i] === needle[0]) { 
                if (haystack.substring(i, i + needle.length) === needle) return i;
            }
        }
        return -1
    };

### 搜索插入位置：`简单` ###

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

你可以假设数组中无重复元素。

示例 1:

输入: \[1,3,5,6\], 5  
输出: 2  
示例 2:

输入: \[1,3,5,6\], 2  
输出: 1  
示例 3:

输入: \[1,3,5,6\], 7  
输出: 4  
示例 4:

输入: \[1,3,5,6\], 0  
输出: 0

题解：

class Solution { 
        public int searchInsert(int[] nums, int target) { 
            //二分法查找
             int len = nums.length;
             if(len == 0){ 
                 return 0;
             }
    
             if(nums[len - 1] < target){ 
                 return len;
             }
    
             int left=0;
             int right=len-1;
             while(left < right){ 
                 int middle=left+(right-left)/2; //中间指针
                 if(nums[middle] < target){ 
                     // 下一轮搜索区间是 [mid + 1, right]
                     left = middle+1;
                 }else{ 
                     // 下一轮搜索区间是 [left, mid]
                     right = middle;
                 }
             }
             return left;
             
        }
    }

### 两数相加：`中等` ###

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)  
输出：7 -> 0 -> 8  
原因：342 + 465 = 807

题解：

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */
    class Solution { 
        public ListNode addTwoNumbers(ListNode l1, ListNode l2) { 
            ListNode head=new ListNode(0);//输出的链表头
            ListNode p=l1,q=l2,cur=head;
            int a=0; //进位的数记录
            while(p!=null || q!=null){ 
                int x=(p!=null)?p.val:0;
                int y=(q!=null)?q.val:0;
                int s=a+x+y;
                a=s/10;
                cur.next = new ListNode(s%10);
                cur=cur.next;
                if(p!=null) p=p.next;
                if(q!=null) q=q.next;
            }
            if(a>0){  //若最后还有进位，则a=1
                cur.next=new ListNode(a);
            }
            return head.next;//head->7->0->8
           
        }
    }

### 无重复字符的最长字串：`中等` ###

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: “abcabcbb”  
输出: 3  
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。  
示例 2:

输入: “bbbbb”  
输出: 1  
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。  
示例 3:

输入: “pwwkew”  
输出: 3  
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。  
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。

题解：

class Solution { 
        public int lengthOfLongestSubstring(String s) { 
            Set<Character> son = new HashSet<Character>();
            // 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
            int point = -1,len = 0;
            for(int i=0;i<s.length();++i){ 
                if(i!=0){ 
                    // 左指针向右移动一格，移除一个字符
                    son.remove(s.charAt(i-1));
                }
                while(point+1<s.length() && !son.contains(s.charAt(point+1))){ 
                     // 不断地移动右指针(向右)
                    son.add(s.charAt(point+1));
                    ++point;
                }
                len = Math.max(len,point-i+1);//取最大的长度
            }
            return len;
        }
    }

[LeetCode]: https://leetcode-cn.com