Leetcode 11-20刷题笔记（非困难题目）

11.盛最多水的容器

给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

说明：你不能倾斜容器，且 n 的值至少为 2。

解题思路：
本题针对这种有两条边界的问题，一般都会想到使用双指针方法。

主要的算法考虑好后，那么就就需要针对问题进行判断如何让指针进行移动。

这里因为我们需要求的是最大的盛水量，然后该题的盛水量 = （指针下标差）* （两指针的高度较小值） 。
这里我们可以发现我们需要的关键值就是高度较小值（因为高度较高值确定你能达到的最大高度，高度较小值确定的是实际盛水量高度），所以确定了，我们需要移动较小值高度的指针，并且每次记录此时的最高值。

本题解题思路结束

class Solution {
    //盛最多的数
    public int maxArea(int[] height) {
        //滑动窗口法
        int left = 0;
        int right = height.length - 1;
        int max = 0;
            while(left < right) {
                max = Math.max(Math.min(height[right],height[left]) * (right - left),max);
                if(height[left] > height[right]) {
                    right--;
                }else {
                    left++;
                }
            }
            return max;
    }

}

12.整数转罗马数字

罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。
例如， 罗马数字 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 的范围内。

输入: 9
输出: “IX”

解题思路：
本题的解题思路就是使用贪心算法 + 数组。
数组保存所有可能的罗马字符对应的数字，按照顺序进行除（贪心算法）。

没有任何的难度，所以直接上代码

class Solution {
    int[] values = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};    
    String[] symbols = {"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};

    public String intToRoman(int num) {
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < values.length && num >= 0; i++) {
            while (values[i] <= num) {
                num -= values[i];
                sb.append(symbols[i]);
            }
        }
        return sb.toString();
    }

}

13.罗马数字转整数

也是一样的思想，将对应值存储起来的方法，唯一需要注意的一点就是罗马字符如果当前字符大于前一位字符，代表这两个字符时一对，则实际数字为（当前数字 - 上一位数字，类似 IV = 4）。

import java.util.*;

class Solution {
    public int romanToInt(String s) {
        int sum = 0;
        int preNum = getValue(s.charAt(0));
        for(int i = 1;i < s.length(); i ++) {
            int num = getValue(s.charAt(i));
            if(preNum < num) {
                sum -= preNum;
            } else {
                sum += preNum;
            }
            preNum = num;
        }
        sum += preNum;
        return sum;
    }
    
    private int getValue(char ch) {
        switch(ch) {
            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;
        }
    }
}

14.最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”。

输入: [“flower”,“flow”,“flight”]
输出: “fl”

解题思路：
该题目我使用的是纵向比较，即一个个匹配字符串的对应位置是否相同。

1.思路是首先获取字符串数组中最短字符串的长度。（以保证不越界）
2.通过选取数组第一位的对应字符作为基准，如果出现一个不符合的即匹配失败，跳出循环。

思路十分简单，下面给出代码

class Solution {
    //最长公共前缀
    public String longestCommonPrefix(String[] strs) {
        StringBuilder stringBuilder = new StringBuilder();
        if(strs.length == 0) {
            return "";
        }
        int minLen = 10000000;
        //获取最小长度
        for(String str : strs) {
            minLen = Math.min(str.length(),minLen);
        }
        for(int i=0; i<minLen; i++) {
            char a = strs[0].charAt(i);
            boolean flag = true;

            for(String str : strs) {
                if(str.charAt(i) != a) {
                    flag = false;
                    break;
                }
            }
            if(flag) {
                stringBuilder.append(a);
            }else {
                break;
            }
        }

        return stringBuilder.toString();
    }

}

15.三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。

给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]

解题思路：
题目的要求我们首先需要看清楚：
1.需要三个数（必须是三个数）
2.不可重复的三元组
3.三个数和为0

根据这个不可重复这个条件我们可以得出，必须要对数组进行排序，不然乱序的情况下，很难保证不重复。

我们之前写过两数之和，那么我们可以这样思考。
能不能把三数之和转化成一个数和两数之和？

这样的话，我们就有了一个思路，就是需要编写一个三数之和的方法和两数之和的方法。

因为数组已经是排过序的了，所以三数之和部分可以给方法进行剪枝。
两数之和也可以使用双指针法，根据与目标值的差距关系挪动指针。

注意：
针对不可重复部分需要进行语句判断的continue操作，具体逻辑需要思考。

因为本题并不是难题，所以直接附上代码更为有效果

import java.util.*;

class Solution {
    //三数之和，即让三数之和 = 0
    //三数之和 -> value 和 [-value]的两数之和问题
    public List<List<Integer>> threeSum(int[] nums) {
        //给数组排序
        Arrays.sort(nums);
        List<List<Integer>> lists = new ArrayList<>();
        threeSum(lists,nums,new ArrayList<>());
        return lists;
    }

    public void threeSum(List<List<Integer>> lists, int[] nums,List<Integer> list) {
        for(int i=0; i<nums.length; i++) {
            //数组排过序，所以大于0后面不用考虑
            if(nums[i] > 0) {
                break;
            }
            //防止重复
            if(i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            list.add(nums[i]);
            twoSum(lists,nums,-nums[i],i + 1,list);
            //清空List
            list.clear();
        }
    }

    public void twoSum(List<List<Integer>> lists, int[] nums, int value, int index, List<Integer> list) {
        int left = index;
        int right = nums.length - 1;
        while(left < right) {
            //防止重复
            if(left > index && nums[left] == nums[left - 1]) {
                left++;
                continue;
            }
            //防止重复
            if(right < nums.length - 1 && nums[right] == nums[right + 1]) {
                right--;
                continue;
            }
            int sum = nums[left] + nums[right];
            if(sum > value) {
                right--;
            }else if(sum == value) {
                list.add(nums[left]);
                list.add(nums[right]);
                //符合添加到Lists中
                lists.add(new ArrayList<>(list));
                //删除最后两位，继续寻找
                list.remove(1);
                list.remove(1);
                //此时挪动那边指针都可以
                left++;
            }else {
                left++;
            }
        }
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        int[] nums = {0,0,0,0};
        System.out.println(solution.threeSum(nums));
    }

}

16.最接近的三数之和

这个和上面也是一样的，主要就是将三数之和 -> 两数之和的问题。

这里需要注意的一点就是，这里因为求的是最接近的数，所以其实是类似于数轴上面的两个数字间的距离，因为数字存在大小关系，所以需要将两数之差加上绝对值在进行比较究竟哪个举例更近一些。

下面奉上代码

import java.util.*;

class Solution {
    //最接近三数之和
    public int threeSumClosest(int[] nums, int target) {
        //排序
        Arrays.sort(nums);
        int minDiff = 10000000;
        int result = 1000000;
        for(int i=0; i<nums.length; i++) {
            if(i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            int i1 = twoSum(nums, i + 1, target - nums[i]);
            if(minDiff > Math.abs(target - nums[i] - i1)) {
                minDiff = Math.abs(target - nums[i] - i1);
                result = nums[i] + i1;
            }
        }
        return result;
    }

    //转换成最接近的二数之和
    public int twoSum(int[] nums, int index, int target) {
        int minDiff = 100000000;
        int result = 10000000;
        int left = index;
        int right = nums.length - 1;
        while(left < right) {
            int sum = nums[left] + nums[right];
            if(minDiff > Math.abs(target - sum)) {
                minDiff = Math.abs(target - sum);
                result = sum;
            }
            if(sum > target) {
                right--;
            }else if(sum < target) {
                left++;
            }else { //相等时，直接return sum，此时无差距
                result = sum;
                break;
            }
        }
        return result;
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        int[] nums = {-1,1,2,4};
        System.out.println(solution.threeSumClosest(nums, 1));
    }

}

17.电话号码的字母组合

该题目典型回溯题目，题目较简单，说到底就是一个全排列题目，算是回溯算法入门。

该题目技巧在于使用Map保存对应电话按键所代表的的字符集合。

下面直接奉上代码。

import java.util.*;

class Solution {

    public List<String> letterCombinations(String digits) {
        List<String> combinations = new ArrayList<String>();
        if (digits.length() == 0) {
            return combinations;
        }
        Map<Character, String> phoneMap = new HashMap<Character, 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");
        }};
        backTrace(phoneMap,combinations,new StringBuilder(),digits,0);
        return combinations;
    }

    public void backTrace(Map<Character,String> map,List<String> list,StringBuilder stringBuilder,String digits,int index) {
        //遍历结束
        if(index == digits.length()) {
            //添加全排列组合
            list.add(stringBuilder.toString());
            return;
        }

        char target = digits.charAt(index);
        String msg = map.get(target);

        for(int i=0; i<msg.length(); i++) {
            stringBuilder.append(msg.charAt(i));
            //递归
            backTrace(map, list, stringBuilder, digits, index + 1);
            //回溯
            stringBuilder.deleteCharAt(index);
        }
    }

}

18.四数之和

该题目思路和三数之和一样，主要就是进行降维转换。

四数之和 -> 三数之和 -> 二数之和

思路完全一样，下面直接奉上代码。

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

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

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

给定一个链表: 1->2->3->4->5, 和 n = 2.
当删除了倒数第二个节点后，链表变为 1->2->3->5.

本题也没有什么难度，就是有几个特殊的点需要注意，比如删除头结点和删除尾结点的两个部分需要特殊考虑一下。

class Solution {
    //删除倒数n个结点
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //获取链表长度
        int len = getLen(head);
        if(len == 0) {
            return null;
        }
        //将倒数转换成正数
        int deleteIndex = len - n + 1;
        //先对特殊情况进行处理
        if(deleteIndex == 1) { //删除头结点
            head = head.next;
            return head;
        }
        //我们需要获取到待删除节点的上一个结点
        ListNode temp = head;
        //我们这里的结点都是从 1 开始计数的
        int index = 1;
        while(index != deleteIndex - 1) {
            temp = temp.next;
            index++;
        }
        //如果删除的结点为最后一个结点
        if(deleteIndex == len) {
            temp.next = null;
        }else {
            temp.next = temp.next.next;
        }
        return head;
    }

    public int getLen(ListNode head) {
        if(head == null) {
            return 0;
        }
        int len = 0;
        while(head != null) {
            head = head.next;
            len++;
        }
        return len;
    }
}

class ListNode {
    int val;
    ListNode next;

    ListNode() {
    }

    ListNode(int val) {
        this.val = val;
    }

    ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

20.有效的括号

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
1.左括号必须用相同类型的右括号闭合。
2.左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

我们这里使用一个Stack来方便我们进行括号的匹配，我们只需要栈顶元素进行判断是否符合，如果符合的话就直接弹出栈顶元素，如果不符合的话就入栈。

import java.util.Stack;

class Solution {
    public boolean isValid(String s) {
        //判空处理
        if(s == null || s.length() == 0) {
            return true;
        }

        Stack<Character> stack = new Stack<>();

        for(int i=0; i<s.length(); i++) {
            if(stack.size() > 0) {
                //匹配成功
                if (check(stack.peek(),s.charAt(i))) {
                    stack.pop();
                    continue;
                }
            }
            stack.push(s.charAt(i));
        }

        //如果是合法的括号的话，那么此时的 stack 的 size 应该为 0  
        if(stack.size() > 0) {
            return false;
        }
        return true;
    }

    public boolean check(Character a, Character b) {
        if(a == '(' && b == ')') {
            return true;
        }
        if(a == '[' && b == ']') {
            return true;
        }
        if(a == '{' && b == '}') {
            return true;
        }

        return false;
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        solution.isValid("()[]{}");
    }
}