LeetCode刷题整理（9.24）

20. 有效的括号

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

有效字符串需满足：

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

示例 1:

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

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

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

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

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

解题思路：
判断要进入的和已经进入的最后一个能不能抵消可以的话就把最后一个remove，最后判断列表中是不是空，

class Solution {
    public boolean isValid(String s) {
        ArrayList<Character> res = new ArrayList<>();
        for (int i = 0; i < s.length(); i++) {
            if (res.size() == 0) {
                res.add(s.charAt(i));
                continue;
            }
            if (res.get(res.size() - 1).equals('(') && s.charAt(i) == ')') {
                res.remove(res.size() - 1);
                continue;
            }
            if (res.get(res.size() - 1).equals('{') && s.charAt(i) == '}') {
                res.remove(res.size() - 1);
                continue;
            }
            if (res.get(res.size() - 1).equals('[') && s.charAt(i) == ']') {
                res.remove(res.size() - 1);
                continue;
            }
            res.add(s.charAt(i));
        }
        return res.size() <= 0;
    }
}

21. 合并两个有序链表

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

示例：

输入：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) {
        if(l1==null && l2==null) return l1;
        if(l1==null || l2==null) return l1==null? l2:l1;
        ArrayList<Integer> res = new ArrayList<>();
        ListNode l11 = l1;
        ListNode l22 = l2;

        while(l11!=null || l22!=null){
            if(l11==null){
                res.add(l22.val);
                l22 = l22.next;
                continue;
            }
            if(l22==null ){
                res.add(l11.val);
                l11 = l11.next;
                continue;
            }
            if(l11!=null && l22!=null){
                
                if(l11.val<=l22.val){
                    res.add(l11.val);
                    l11 = l11.next;
                    continue;
                }
                if(l11.val>l22.val){
                    res.add(l22.val);
                    l22 = l22.next;
                    continue;
                }
            }
        }
        ListNode number = l1;
        ListNode head = l1;
        while(number.next!=null){
            number = number.next;
        }
        number.next = l2;
        int i =0;
        System.err.println(res.size());
        while(l1!=null){
            l1.val = res.get(i);
            i++;
            l1 = l1.next;
        }
        return head;

    }
}

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

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

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 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;
        if(nums.length==1) return 1;
        int l = 0 , r = 1;
        while (r < nums.length) {
            if(nums[r]!=nums[l]){
                nums[l+1] = nums[r];
                r++;
                l++;
                continue;
            }
            if(nums[r]==nums[l]){
                r++;
            }
        }
        return l+1;
    }
}

27. 移除元素

给你一个数组 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。

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

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

先判断最后返回的是多长的数组，之后按着这个长度来移动每个数，如果遍历到的数和val不相等就下一个，想等的话就找到下一个不相等交换，一直遍历到达到要求的length。

class Solution {
    public int removeElement(int[] nums, int val) {
        int length = nums.length;
        for (int num : nums) {
            if (num == val) length--;
        }
        for (int i = 0; i < length; i++) {
            if (nums[i] == val) {
                for (int j = i; j < nums.length; j++) {
                    if (nums[j] != nums[i]) {
                        int temp = nums[j];
                        nums[j] = nums[i];
                        nums[i] = temp;
                        break;
                    }

                }
            }
        }
        return length;
    }
}