leecode刷题记录 ---＞ 1，2，3，4，5，6，7，9，13，14，20，21，26，27，28，35，42

tips：题目说明没有全拷过来，如果看不懂题可以到leecode网上找下原题（题号都是对应的）

1. 两数之和

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

题解：

class Solution {
    public int[] twoSum(int[] nums, int target) 
    {
        for( int i = 0 ; i < nums.length ; i ++)
        {
            for( int j = i + 1 ; j < nums.length ; j++)
            {
                if( nums[i] + nums[j] == target)
                {
                    int [] result = { i , j };
                    return result;
                }
            }
        }
        return null ;
    }
}

2.两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

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

/**
 * 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 dummyHead = new ListNode(0);
    ListNode p = l1, q = l2, curr = dummyHead;
    int carry = 0;
    while (p != null || q != null) {
        int x = (p != null) ? p.val : 0;
        int y = (q != null) ? q.val : 0;
        int sum = carry + x + y;
        carry = sum / 10;
        curr.next = new ListNode(sum % 10);
        curr = curr.next;
        if (p != null) p = p.next;
        if (q != null) q = q.next;
    }
    if (carry > 0) {
        curr.next = new ListNode(carry);
    }
    return dummyHead.next;
     }
     
}

3.无重复字符的最长子串

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

示例 1:

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

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

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

输入: s = “”
输出: 0

题解：

class Solution {
     public int lengthOfLongestSubstring(String s) {
        if(" ".equals(s)) return 1;
        if(s.length()==0) return 0;
        char[] chars = s.toCharArray();
        ArrayBlockingQueue abq=new ArrayBlockingQueue(s.length());
        int max=0;
        for(int i=0;i<s.length();i++)
        {
            if(!abq.contains(chars[i]))
            {
                abq.offer(chars[i]);
                if(abq.size()>max) max=abq.size();
            }
            else
            {
                abq.poll();
                i--;
            }
        }
        return max;
    }
}

4. 寻找两个正序数组的中位数

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

算法的时间复杂度应该为 O(log (m+n)) 。

示例 1：

输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2
示例 2：

输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5
示例 3：

输入：nums1 = [0,0], nums2 = [0,0]
输出：0.00000
示例 4：

输入：nums1 = [], nums2 = [1]
输出：1.00000
示例 5：

输入：nums1 = [2], nums2 = []
输出：2.00000
题解：

class Solution {
   public double findMedianSortedArrays(int[] nums1, int[] nums2)
    {
        int[] nums=new int[nums1.length+nums2.length] ;
        int i=0,j=0,k=0;
        while(k<nums.length && i<nums1.length && j<nums2.length)
        {
            if(nums1[i]>nums2[j])
            {
                nums[k]=nums2[j++];
            }
            else if(nums1[i]<nums2[j])
            {
                nums[k]=nums1[i++];
            }
            else if(nums1[i]==nums2[j])
            {
                nums[k]=nums2[j++];
                nums[++k]=nums1[i++];
            }
            k++;
        }
        if(i==nums1.length)
        {
            for(;j<nums2.length;j++)
            {
                nums[k++]=nums2[j];
            }
        }
        else if(j==nums2.length)
        {
            for(;i<nums1.length;i++)
            {
                nums[k++]=nums1[i];
            }
        }

        double result=0;
        if(nums.length%2!=0)
        {
            return nums[nums.length/2];
        }
        return ((double)nums[nums.length/2-1]+(double)nums[nums.length/2])/2;
    }
}

5. 最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。
示例 1：

输入：s = “babad”
输出：“bab”
解释：“aba” 同样是符合题意的答案。
示例 2：

输入：s = “cbbd”
输出：“bb”
示例 3：

输入：s = “a”
输出：“a”
示例 4：

输入：s = “ac”
输出：“a”

题解：

class Solution {
    public String longestPalindrome(String s)
    {
        if(s.length()<2) return s;
        int max_length=s.length();
        while(max_length>=1) {
            for (int i = 0; i < s.length() ; i++) {
                if(max_length+i <=s.length()){
                    String s_try=s.substring(i,max_length+i);
                    if(max_length<2) return s_try;
                    if (isHuiWen(s_try)) {
                        return s_try;
                    }
                }
            }
            max_length--;
        }
        return null;
    }
    public boolean isHuiWen(String s)
    {
        for(int i=0;i<s.length()/2;i++)
        {
            if(s.charAt(i)!=s.charAt(s.length()-i-1))
                return false;
        }
        return true;
    }
}

6. Z 字形变换

将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。

比如输入字符串为 “PAYPALISHIRING” 行数为 3 时，排列如下：

P A H N
A P L S I I G
Y I R
之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：“PAHNAPLSIIGYIR”。

请你实现这个将字符串进行指定行数变换的函数：

string convert(string s, int numRows);

题解：

class Solution {
    public String convert(String s, int numRows) {
       if(s.length()==0) return "";
        if(numRows==1) return s;
        char[][] result=new char[numRows][s.length()/2+1];
        int j=0,i=0;
         while (s.length()!=0)
        {
            for(;i<numRows;i++)
            {
                if(s.length()==0)
                    break;
                result[i][j]=s.charAt(0);
                s=s.substring(1);
            }
            i--;
            while (i != 0 && s.length()!=0 )
            {
               i--;
                j++;
                result[i][j]=s.charAt(0);
                s=s.substring(1);
            }
            i++;
        }
        String s1 = "";
        for(int k = 0;k<numRows;k++)
            for(int k_1=0;k_1<result[k].length;k_1++)
            {
                if(result[k][k_1]!='\u0000')
                s1+=result[k][k_1];
            }
        return  s1;
    }
}

7. 整数反转

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。

示例 1：

输入：x = 123
输出：321
示例 2：

输入：x = -123
输出：-321
示例 3：

输入：x = 120
输出：21
示例 4：

输入：x = 0
输出：0

题解：

class Solution {
   public int reverse(int x) {
        int y = 0;
        while (x != 0) {
            if (y > 214748364 || y < -214748364) {
                return 0;
            }
            y = y * 10 + x % 10;
            x = x / 10;
        }
        return y;
    }
}

9. 回文数

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。

示例 1：

输入：x = 121
输出：true
示例 2：

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

输入：x = 10
输出：false
解释：从右向左读, 为 01 。因此它不是一个回文数。
示例 4：

输入：x = -101
输出：false

题解：

class Solution {
     public boolean isPalindrome(int x)
    {
        if(x < 0) return false;
        String s = x + "";
        for (int i = 0; i< s.length() / 2; i++)
        {
            if(s.charAt(i) != s.charAt(s.length() - i - 1))
                return false;
        }
        return true;
    }
}

13. 罗马数字转整数

罗马数字包含以下七种字符: 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。
给定一个罗马数字，将其转换成整数。

题解：

class Solution {
    public int romanToInt(String s) {
        Map<String, Integer> map = new HashMap<>();
        map.put("I", 1);
        map.put("IV", 4);
        map.put("V", 5);
        map.put("IX", 9);
        map.put("X", 10);
        map.put("XL", 40);
        map.put("L", 50);
        map.put("XC", 90);
        map.put("C", 100);
        map.put("CD", 400);
        map.put("D", 500);
        map.put("CM", 900);
        map.put("M", 1000);
        
        int ans = 0;
        for(int i = 0;i < s.length();) {
            if(i + 1 < s.length() && map.containsKey(s.substring(i, i+2))) {
                ans += map.get(s.substring(i, i+2));
                i += 2;
            } else {
                ans += map.get(s.substring(i, i+1));
                i ++;
            }
        }
        return ans;
    }
}

14. 最长公共前缀

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

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

示例 1：

输入：strs = [“flower”,“flow”,“flight”]
输出：“fl”
示例 2：

输入：strs = [“dog”,“racecar”,“car”]
输出：“”
解释：输入不存在公共前缀。
题解：

class Solution {
    public String longestCommonPrefix(String[] strs)
    {
        if(strs.length == 0) return "";
        int min = strs[0].length() ;
        boolean mark = true;
        int i = 0 ;
        int j = 0;
        for(i = 0 ; i < strs.length ; i ++)
        {
            min = Math.min(min , strs[i].length());
        }
        for (i = 0 ; i < min; i++)
        {
            for(j = 0 ; j < strs.length - 1 ; j ++)
            {
                if(strs[j].charAt(i) != strs[j + 1].charAt(i))
                {
                        return strs[0].substring(0 , i);
                }
            }
        }
        return strs[0].substring(0 , i);
    }
}

20. 有效的括号

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

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
示例 1：

输入：s = “()”
输出：true
示例 2：

输入：s = “()[]{}”
输出：true
示例 3：

输入：s = “(]”
输出：false
示例 4：

输入：s = “([)]”
输出：false
示例 5：

输入：s = “{[]}”
输出：true

题解：

class Solution {
    public boolean isValid(String s) {
        if(s.isEmpty())
            return true;
        Stack<Character> stack=new Stack<Character>();
        for(char c:s.toCharArray()){
            if(c=='(')
                stack.push(')');
            else if(c=='{')
                stack.push('}');
            else if(c=='[')
                stack.push(']');
            else if(stack.empty()||c!=stack.pop())
                return false;
        }
        if(stack.empty())
            return true;
        return false;
    }
}

21. 合并两个有序链表

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

题解：

/**
 * 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) {
        if (l1 == null) {
            return l2;
        } else if (l2 == null) {
            return l1;
        } else if (l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        } else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }

    }
}

26. 删除有序数组中的重复项

给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。

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

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}

题解：

class Solution {
    public int removeDuplicates(int[] nums)
    {
        if(nums.length == 0) return 0;
        if(nums.length == 1) return 1;
        int index = 0;
        int count = nums[0];
        for(int i = 0 ; i < nums.length ; i ++)
        {
            if(nums[i] >= count)
            {
                nums[index] = nums[i];
                count = nums[index] + 1;
                index ++;
            }
        }
        return  index;
    }
}

27. 移除元素

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

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

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

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。
示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

题解：

class Solution {
    public int removeElement(int[] nums, int val)
    {
        int index = 0;
        int i = 0;
        for (; i < nums.length ; i ++)
        {
            if(nums[i] != val)
            {
                nums[index] = nums[i];
                index ++;
            }
        }
        return index;
    }
}

28. 实现 strStr()

实现 strStr() 函数。

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。

说明：

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

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

示例 1：

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

输入：haystack = “aaaaa”, needle = “bba”
输出：-1
示例 3：

输入：haystack = “”, needle = “”
输出：0

题解：

class Solution {
    public int strStr(String haystack, String needle)
    {
        if(needle.equals("")) return 0;
        if(haystack.equals("")) return -1;
        int i = 0;
        int j = 0;
        while (haystack.length() - i >= needle.length())
        {
            if(haystack.charAt(i) == needle.charAt(j))
            {
                int cur_i = i;
                for(; j < needle.length() ; j ++)
                {
                    if(haystack.charAt(cur_i + j) != needle.charAt(j))
                        break;
                }
                if(j == needle.length()) return i;
            }
            i++;
            j = 0;
        }
        return -1;
    }
}

35. 搜索插入位置

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

请必须使用时间复杂度为 O(log n) 的算法。

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2
示例 2:

输入: nums = [1,3,5,6], target = 2
输出: 1
示例 3:

输入: nums = [1,3,5,6], target = 7
输出: 4
示例 4:

输入: nums = [1,3,5,6], target = 0
输出: 0
示例 5:

输入: nums = [1], target = 0
输出: 0

题解：

class Solution {
    public int searchInsert(int[] nums, int target)
    {
        int a = Arrays.binarySearch(nums , target);
        if( a >= 0)
            return a;
        for(int i = 0 ; i < nums.length ; i ++)
        {
            if(target < nums[i])
                return i;
        }
        return nums.length;
    }
}

38. 外观数列

给定一个正整数 n ，输出外观数列的第 n 项。

「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。

你可以将其视作是由递归公式定义的数字字符串序列：

countAndSay(1) = “1”
countAndSay(n) 是对 countAndSay(n-1) 的描述，然后转换成另一个数字字符串。
前五项如下：

1. 1
   

2. 11
   

3. 21
   

4. 1211
   

5. 111221
   

第一项是数字 1
描述前一项，这个数是 1 即 “ 一 个 1 ”，记作 “11”
描述前一项，这个数是 11 即 “ 二 个 1 ” ，记作 “21”
描述前一项，这个数是 21 即 “ 一 个 2 + 一 个 1 ” ，记作 “1211”
描述前一项，这个数是 1211 即 “ 一 个 1 + 一 个 2 + 二 个 1 ” ，记作 “111221”
要 描述 一个数字字符串，首先要将字符串分割为 最小 数量的组，每个组都由连续的最多 相同字符 组成。然后对于每个组，先描述字符的数量，然后描述字符，形成一个描述组。要将描述转换为数字字符串，先将每组中的字符数量用数字替换，再将所有描述组连接起来。

题解：

class Solution {
    public String countAndSay(int n)
    {
        if (n == 1)
        {
            return "1";
        }
        StringBuffer res = new StringBuffer();
        String str = countAndSay(n - 1);
        int length = str.length();
        int start = 0;
        for (int i = 1; i < length + 1; i++)
        {
            if (i == length)
            {
                res.append(i - start).append(str.charAt(start));
            } else if (str.charAt(i) != str.charAt(start) )
            {
                res.append(i - start).append(str.charAt(start));
                start = i;
            }
        }
        return res.toString();
    }
}

42. 接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。
示例 2：

输入：height = [4,2,0,3,2,5]
输出：9

题解：

class Solution {
   public int trap(int[] height)
    {
        int max_left[] =new int[height.length] ;
        int max_right[] =new int[height.length] ;
        int max=0;
        for(int i=0;i<height.length;i++)
        {
            if(height[i]>max)
            {
                max=height[i];
                max_left[i]=height[i];
            }
            else {
                max_left[i]=max;
            }
        }
        max=0;
        for(int i=height.length-1;i>=0;i--)
        {
            if(height[i]>max)
            {
                max=height[i];
                max_right[i]=height[i];
            }
            else {
                max_right[i]=max;
            }
        }
        int result=0;
        for(int i=0;i<height.length;i++)
        {
            result+=Math.min(max_left[i],max_right[i])-height[i];
        }
        return result;
    }
}