力扣刷题java

#1
#两数之和
#给定一个整数数组nums和一个整数目标值 target，请你在该数组中找出 和为目标值 target的那两个整数，并返回它们的数组下标。
#你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
#你可以按任意顺序返回答案。
class Solution {
   
    public int[] twoSum(int[] nums, int target) {
   
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i< nums.length; i++) {
   
            if(map.containsKey(target - nums[i])) {
   
                return new int[] {
   map.get(target-nums[i]),i};
            }
            map.put(nums[i], i);
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

#2
#整数反转
#给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
#如果反转后整数超过 32 位的有符号整数的范围 [−231,  231 − 1] ，就返回 0。
#假设环境不允许存储 64 位整数（有符号或无符号）。
class Solution {
   
	public int reverse(int x) {
   
	    int ans = 0;
	    while (x != 0) {
   
	        int pop = x % 10;
	        if (ans > Integer.MAX_VALUE / 10 || (ans == Integer.MAX_VALUE / 10 && pop > 7)) 
	            return 0;
	        if (ans < Integer.MIN_VALUE / 10 || (ans == Integer.MIN_VALUE / 10 && pop < -8)) 
	            return 0;
	        ans = ans * 10 + pop;
	        x /= 10;
	    }
	    return ans;
	}
}

#3
#回文数
#给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
#回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。
 public boolean isPalindrome(int x) {
   
        if (x < 0) {
   
            return false;
        }
        int help = 1;
        int tmp = x;
        while (tmp >= 10) {
   
            help *= 10;
            tmp /= 10;
        }
        while (x != 0) {
   
            if (x % 10 != x / help) {
   
                return false;
            }
            x = x % help / 10;
            help /= 100;
        }
        return true;
	}

#4
#罗马数字转整数
#I 1
#V 5
#X 10
#L 50
#C 100
#D 500
#M 1000

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;
    }
}

#5
#最长公共前缀
#编写一个函数来查找字符串数组中的最长公共前缀。
#如果不存在公共前缀，返回空字符串 ""。
class Solution {
   
    public String longestCommonPrefix(String[] strs) {
   
        if(strs.length == 0) 
            return "";
        String ans = strs[0];
        for(int i =1;i<strs.length;i++) {
   
            int j=0;
            for(;j<ans.length() && j < strs[i].length();j++) {
   
                if(ans.charAt(j) != strs[i].charAt(j))
                    break;
            }
            ans = ans.substring(0, j);
            if(ans.equals(""))
                return ans;
        }
        return ans;
    }
}

#6
#有效的括号
#给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
#有效字符串需满足：
#左括号必须用相同类型的右括号闭合。
#左括号必须以正确的顺序闭合。
class Solution {
   
    public boolean isValid(String s) {
   
        int n = s.length();
        if (n % 2 == 1) {
   
            return false;
        }

        Map<Character, Character> pairs = new HashMap<Character, Character>() {
   {
   
            put(')', '(');
            put(']', '[');
            put('}', '{');
        }};
        Deque<Character> stack = new LinkedList<Character>();
        for (int i = 0; i < n; i++) {
   
            char ch = s.charAt(i);
            if (pairs.containsKey(ch)) {
   
                if (stack.isEmpty() || stack.peek() != pairs.get(ch)) {
   
                    return false;
                }
                stack.pop();
            } else {
   
                stack.push(ch);
            }
        }
        return stack.isEmpty();
    }
}

#7
#合并两个有序链表
#将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 
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;
        }

    }
}

#8
#删除有序数组中的重复项
class Solution {
   
    public int removeDuplicates(int[] nums) {
   
        int n = nums.length;
        if (n == 0) {
   
            return 0;
        }
        int fast = 1, slow = 1;
        while (fast < n) {
   
            if (nums[fast] != nums[fast - 1]) {
   
                nums[slow] = nums[fast];
                ++slow;
            }
            ++fast;
        }
        return slow;
    }
}

#9
#移除元素
#给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
#不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
#元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
class Solution {
   
    public int removeElement(int[] nums, int val) {
   
        int j = nums.length - 1;
        for (int