力扣算法练习与解答笔记(1-10)

1、两数之和

给定一个整数数组 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 numMap = new HashMap<>();
        for(int i = 0; i < nums.length; i++) {
            int num = nums[i];
            int needNum = target - num;
            if(!numMap.containsKey(needNum)) {
                numMap.put(num, i);
                continue;
            }
            return new int[]{numMap.get(needNum), i};
        }
        return new int[]{};
    }
}

2、机器人大冒险

力扣团队买了一个可编程机器人，机器人初始位置在原点(0, 0)。小伙伴事先给机器人输入一串指令command，机器人就会无限循环这条指令的步骤进行移动。指令有两种：

U: 向y轴正方向移动一格
R: 向x轴正方向移动一格。
不幸的是，在 xy 平面上还有一些障碍物，他们的坐标用obstacles表示。机器人一旦碰到障碍物就会被损毁。

给定终点坐标(x, y)，返回机器人能否完好地到达终点。如果能，返回true；否则返回false。

示例 1：

输入：command = "URR", obstacles = [], x = 3, y = 2
输出：true
解释：U(0, 1) -> R(1, 1) -> R(2, 1) -> U(2, 2) -> R(3, 2)

解答：

class Solution {
    public boolean robot(String command, int[][] obstacles, int x, int y) {
        if(command ==null || command.length() < 2 || command.length() > 1000 || !command.contains("U") || !command.contains("R")) {
            return false;
        }
        long max = (long)Math.pow(10, 9);
        if(x < 0 || x > max || y < 0 || y > max) {
            return false;
        }
        if(obstacles == null || obstacles.length < 0 || obstacles.length > 1000) {
            return false;
        }
        int validObstacleCount = 0;
        for(int i = 0; i  x || currentY > y) {
                    loop = false;
                    break;
                }
                if(currentX == x && currentY == y) {
                    canArriveDest = true;
                }
                for(int j = 0; j < validObstacleCount; j++) {
                    int[] obstacle = obstacles[j];
                    if(currentX == obstacle[0] && currentY == obstacle[1]) {
                        return false;
                    }
                }
            }
        }
        return canArriveDest;
    }
}

3、猜数字

小A 和 小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏，请返回 小A 猜对了几次？

输入的guess数组为 小A 每次的猜测，answer数组为 小B 每次的选择。guess和answer的长度都等于3。

示例 1：

输入：guess = [1,2,3], answer = [1,2,3]
输出：3
解释：小A 每次都猜对了。

解答：

class Solution {
    public int game(int[] guess, int[] answer) {
        if(guess == null || answer == null || guess.length == 0 || answer.length == 0) {
            return 0;
        }
        int guessLen = guess.length;
        int answerLen = answer.length;
        int count = 0;
        for(int i = 0; i < Math.min(guessLen, answerLen); i ++) {
            if(i >= guessLen || i >= answerLen) {
                break;
            }
            if(guess[i] == answer[i]) {
                count++;
            }
        }    
        return count;
    }
}

4、两数相加

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

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

您可以假设除了数字 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 node = null;
        ListNode currentNode = null;
        boolean loop = true;
        boolean upStep = false;//是否进位
        while(loop) {
            int l1Val = 0;
            int l2Val = 0;
            if(l1 != null) {
                l1Val = l1.val;
            }
            if(l2 != null) {
                l2Val = l2.val;
            }
            int sum = l1Val + l2Val;
            if(upStep) {
                sum++;
                upStep = false;
            }
            if(l1 == null && l2 == null) {
                loop = false;
                if(sum == 0) {
                    break;
                }
            }
            upStep = sum >= 10;
            if(node == null) {
                node = new ListNode(sum % 10);
                currentNode = node;
            } else {
                currentNode.next = new ListNode(sum % 10);
                currentNode = currentNode.next;
            }
            if(l1 != null) {
                l1 = l1.next;    
            }
            if(l2 != null) {
                l2 = l2.next;
            }
        }
        return node;
    }
}

5、无重复字符的最长子串

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

示例 1:

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

解答：

class Solution {
    public int lengthOfLongestSubstring(String s) {
        if(s == null || s.equals("")) {
            return 0;
        }
        int len = 1;
        List list = new ArrayList<>();
        char[] strings = s.toCharArray();
        for(int i = 0; i < s.length(); i++) {
            char letter = s.charAt(i);
            if(list.contains(letter)) {
                if(len < list.size()) {
                    len = list.size();
                }
                int idx = list.indexOf(letter);
                if(idx == list.size() - 1) {
                    list.clear();
                } else {
                    for(int j = idx; j >= 0; j--) {
                        list.remove(j);
                    }
                }
            }
            list.add(letter);
        }
        if(len < list.size()) {
            len = list.size();
        }
        return len;
    }
}

6、寻找两个有序数组的中位数

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。

请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

示例 1:

nums1 = [1, 3]
nums2 = [2]

则中位数是 2.0

解答：
先合并两个有序数组，然后根据奇偶数取中位数

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int len1 = nums1 == null ? 0 : nums1.length;
        int len2 = nums2 == null ? 0 : nums2.length;
        List list = new ArrayList<>(len1 + len2);
        if(nums1 == null || nums1.length == 0) {
            for(int i =0; i < nums2.length; i++) {
                list.add(nums2[i]);    
            }
        } else if(nums2 == null || nums2.length == 0) {
            for(int i =0; i < nums1.length; i++) {
                list.add(nums1[i]);    
            }
        } else {
            int i = 0; 
            int j = 0;
            while(i < len1 && j < len2) {
                if(nums1[i] <= nums2[j]) {
                    list.add(nums1[i]);
                    i++;
                } else {
                    list.add(nums2[j]);
                    j++;
                }
            }
            while(i < len1) {
                list.add(nums1[i]);
                i++;
            }
            while(j < len2) {
                list.add(nums2[j]);
                j++;
            }
        }
        Collections.sort(list);
        double value = 0D;
        if(list.size() % 2 == 0) {// 偶数
            int firstIdx = list.size() / 2 - 1;
            value = (list.get(firstIdx) + list.get(firstIdx + 1)) * 1.0 / 2;
        } else {//奇数
            value = list.get(list.size() / 2) * 1.0;
        }   
        return value;
    }
}

7、最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
示例 1：

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。

示例 2：

输入: "cbbd"
输出: "bb"

解答：

class Solution {
    //学习官方中心扩散法
    public String longestPalindrome(String s) {
        if (s == null || s.length() < 1) return "";
        //遍历字符串s，从字符串的每个字符往两边扩散，记录扩散字符串最长的字符串startIdx、endIdx
        int startIdx = 0; int endIdx = 0;
        for(int i = 0; i < s.length(); i++) {
            int len1 = getPalindromeLength(s, i, i);
            int len2 = getPalindromeLength(s, i, i+1);
            int len = Math.max(len1, len2);
            if(len > endIdx - startIdx) {
                startIdx = i - (len - 1)/2;//
                endIdx = i + len/2;
            }
        }
        String result = s.substring(startIdx, endIdx + 1);
        return result;
    }
    
    private int getPalindromeLength(String s, int left, int right) {
        int leftIdx = left;
        int rightIdx = right;
        while(leftIdx >= 0 && rightIdx < s.length() && s.charAt(leftIdx) == s.charAt(rightIdx)) {
            leftIdx--;
            rightIdx++;
        }
        int palindromeLen = rightIdx - leftIdx - 1;
        return palindromeLen;
    }
}

8、Z 字形变换

将一个给定字符串根据给定的行数，以从上往下、从左到右进行 Z 字形排列。
比如输入字符串为 “LEETCODEISHIRING” 行数为 3 时，排列如下：

L   C   I   R
E T O E S I I G
E   D   H   N

之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：“LCIRETOESIIGEDHN”。
请你实现这个将字符串进行指定行数变换的函数：

string convert(string s, int numRows);

示例 :

输入: s = "LEETCODEISHIRING", numRows = 4
输出: "LDREOEIIECIHNTSG"
解释:
L     D     R
E   O E   I I
E C   I H   N
T     S     G

解答：

class Solution {
    public String convert(String s, int numRows) {
        if(numRows <= 1) {
            return s;
        }
        StringBuilder[] sbArray = new StringBuilder[numRows];
        char[] charArray = s.toCharArray();
        int len = charArray.length;
        int i = 0;
        while(i < len) {
            for(int m = 0; m < numRows && i < len; m++) {
                if(sbArray[m] == null) {
                    sbArray[m] = new StringBuilder();
                }
                sbArray[m].append(charArray[i]);
                i++;
            }
            for(int n = numRows - 2; n >= 1 && i < len; n--) {
                if(sbArray[n] == null) {
                    sbArray[n] = new StringBuilder();
                }
                sbArray[n].append(charArray[i]);
                i++;
            }
        }
        StringBuilder sb = new StringBuilder();
        for(int j = 0; j < numRows; j++) {
            if(sbArray[j] != null) {
                sb.append(sbArray[j]);
            }
        }
        return sb.toString();
    }
}

9、整数反转

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

示例 :

输入: 123
输出: 321

输入: -123
输出: -321

输入: 120
输出: 21

解答：

class Solution {
    public int reverse(int x) {
        long result = 0;
        while(x != 0) {
            int lastNum = x % 10;//获取最末位的数值
            result = result * 10 + lastNum;
            x = x / 10;//去除最末位的数值
        }
        if(result > Integer.MAX_VALUE || result < Integer.MIN_VALUE) {
            result = 0;
        }
        return (int)result;
    }
}

10、字符串转换整数 (atoi)

请你来实现一个 atoi 函数，使其能将字符串转换成整数。

首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。

当我们寻找到的第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合起来，作为该整数的正负号；假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。

该字符串除了有效的整数部分之后也可能会存在多余的字符，这些字符可以被忽略，它们对于函数不应该造成影响。

注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换。

在任何情况下，若函数不能进行有效的转换时，请返回 0。

说明：

假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−231, 231 − 1]。如果数值超过这个范围，请返回 INT_MAX (231 − 1) 或 INT_MIN (−231) 。

示例 :

输入: "42"
输出: 42

输入: "   -42"
输出: -42
解释: 第一个非空白字符为 '-', 它是一个负号。
     我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。

输入: "4193 with words"
输出: 4193
解释: 转换截止于数字 '3' ，因为它的下一个字符不为数字。

输入: "words and 987"
输出: 0
解释: 第一个非空字符是 'w', 但它不是数字或正、负号。
     因此无法执行有效的转换。

输入: "-91283472332"
输出: -2147483648
解释: 数字 "-91283472332" 超过 32 位有符号整数范围。 
     因此返回 INT_MIN (−231) 。

解答：

class Solution {
    public int myAtoi(String str) {
        str = str.trim();
        if(str.equals("")) {
            return 0;
        }
        char[] charArray = str.toCharArray();
        if(!isNumber(charArray[0]) && !isSymbol(charArray[0])) {
            return 0;
        }
        StringBuilder sb = new StringBuilder();
        int len = charArray.length;
        boolean hasSymbol = isSymbol(charArray[0]);//是否已经有一个符号了
        for(int i = 0; i < len; i++) {
            if(!isNumber(charArray[i])) {
                if(!hasSymbol || (hasSymbol && i > 0)) {
                    break;
                }    
            }
            sb.append(charArray[i]);
        }
        String valueStr = sb.toString();
        if(valueStr.equals("+") || valueStr.equals("-")) {
            return 0;
        }
        long value = 0;
        try {
            value = Long.valueOf(valueStr);    
        } catch(Exception e) {
            if(valueStr.startsWith("-")) {
                return Integer.MIN_VALUE;
            }
            return Integer.MAX_VALUE;
        }
        
        if(value > Integer.MAX_VALUE) {
            return Integer.MAX_VALUE;
        }
        if(value < Integer.MIN_VALUE) {
            return Integer.MIN_VALUE;
        }
        return (int)value;
    }
    
    private boolean isNumber(char ch) {
        if(ch >='0' && ch <= '9') {
            return true;
        }
        return false;
    }
    
    private boolean isSymbol(char ch) {
        if(ch == '+' || ch == '-') {
            return true;
        }
        return false;
    }
}