力扣(LeetCode)题解------简单_力扣简单题答案pdd

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

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

public int[] twoSum(int[] nums, int target) {
        int[] re = new int[2];
        Map<Integer,Integer> map = new HashMap<>();
        for (int i=0; i<nums.length; i++) {
            int x = nums[i];
            //x是当前值 第一个值  x必然不在map中 那么假如 target-x
            //也就是将期望的与x相加得target的值加入
            //之后一直循环 找到了 结束
            //没找到 将期望的与第二个相加为target的值加入 依次循环
            if (null != map.get(x)){
                re[0] = i;
                re[1] = map.get(x);
                break;
            }else {
                map.put(target-x,i);
            }
        }
        return re;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

7、整数反转
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

public int reverse(int x) {
        //定义为int会溢出
        double result = 0;
        if (x >= 0 && x < 10) {
            return x;
        }
        if (x < 0) {
            x = -x;
            while (x > 0) {
                int y = x % 10;
                result = result * 10 + y;
                x = x / 10;
            }
            result = -result;
            if (result < -Math.pow(2, 31) || result > Math.pow(2, 31) - 1) {
                result = 0;
            }
            return (int) result;
        }
        while (x > 0) {
            int y = x % 10;
            result = result * 10 + y;
            x = x / 10;
        }
        if (result < -Math.pow(2, 31) || result > Math.pow(2, 31) - 1) {
            result = 0;
        }
        return (int) result;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

9、回文数
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

 public boolean isPalindrome(int x) {
        int tem = x;
        if (x<0) {
            return false;
        }
        int re = 0;
        while (x>0) {
            int y = x % 10;
            re = re * 10 + y;
            x = x/10;
        }
//        x的值已经改变了
//        if (re == x) {
//            return true;
//        }

        if (re == tem) {
            return true;
        }
        return false;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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

public boolean isValid(String s) {
        Stack stack = new Stack();
        char[] chars = s.toCharArray();
        for (int i=0; i<chars.length;i++) {
            if (chars[i] == '{'
                    || chars[i] == '['
                    || chars[i] == '(') {
                stack.push(chars[i]);
            }
            if (chars[i] == '}') {
                if (stack.empty() || (char)stack.pop() != '{'){
                    return false;
                }

            }else if (chars[i] == ']') {
                if (stack.empty() || (char)stack.pop() != '['){
                    return false;
                }

            }else if (chars[i] == ')') {
                if (stack.empty() || (char)stack.pop() != '('){
                    return false;
                }
            }
        }
        if (stack.empty()) {
            return true;
        }else {
            return false;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

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

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode newList = new ListNode(0);
        ListNode cur = newList;
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                cur.next = l1;
                cur = cur.next;
                l1 = l1.next;
            }else {
                cur.next = l2;
                cur = cur.next;
                l2 = l2.next;
            }
        }
        if (l1 == null) {
            cur.next = l2;
        }else {
            cur.next = l1;
        }

        return newList.next;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

26、 删除排序数组中的重复项
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

public int removeDuplicates(int[] nums) {
        int len = nums.length;
        //倒数第二个  会和倒数第一个进行比较 故倒数第一个不需要遍历了
        for (int i=0; i<len-1; i++) {
            boolean flag = false;
            if (nums[i] == nums[i+1]) {
                for (int j=i+1; j<len; j++) {
                    nums[j-1] = nums[j];
                }
                //移动之后，长度应该减一，后面的不需要处理
                len--;
                flag = true;
            }
            // i=0；  i-- 之后为-1； 但是执行 for循环的i++之后 返回正确值
            if (flag) {
                i--;
            }
        }
        return len;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

26、官方解（牛逼 没想到）

    /**
     * i指向不重复的最后一个元素 
     * 如果重复 j去看下一个 i不动
     * 如果重复 i增加 将j放到i的位置
     * 直到j遍历所有元素
     * @param nums
     * @return
     */
private int re(int[] nums) {
        if (nums.length == 0) {
            return 0;
        }
        int i = 0;
        for (int j = 1; j < nums.length; j++) {
            if (nums[j] != nums[i]) {
                i++;
                nums[i] = nums[j];
            }
        }
        return i + 1;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

27、移动元素
给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

public int removeElement(int[] nums, int val) {
        if (nums.length == 0) {
            return 0;
        }
        int i=0;
        for (int j=0; j<nums.length; j++) {
            if (nums[j] != val) {
                nums[i] = nums[j];
                i++;
            }
        }
        return i;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

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

/**
 * 二分查找
 * 或者遍历一遍即可
 * @author zhangchunguang
 * 2019/3/13 下午3:47
 */
public int searchInsert(int[] nums, int target) {
        int l=0;
        int h = nums.length-1;
        while (l <= h){
            int m = (l + h) / 2;
            if (target == nums[m]) {
                return m;
            }
            if (target < nums[m]) {
                h = m - 1;
            }
            if (target > nums[m]) {
                l = m + 1;
            }
        }
        if (target < nums[0]){
            return 0;
        }
        if (target > nums[l-1]){
            return l ;
        }else if (target < nums[l-1]){
            return l - 1;
        }
        return -1;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

53、最大子序和
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

public int maxSubArray(int[] nums) {
        int sum = 0;
        int res = Integer.MIN_VALUE;
        for (int i=0; i<nums.length; i++) {
            if (sum > 0) {
                sum += nums[i];
            }else {
                sum = nums[i];
            }
            res = Math.max(sum,res);
        }
        return res;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

58、最后一个单词的长度
给定一个仅包含大小写字母和空格 ’ ’ 的字符串，返回其最后一个单词的长度。
如果不存在最后一个单词，请返回 0 。

public int lengthOfLastWord(String s) {

        if (s.trim().isEmpty()) {
            return 0;
        }
        String[] strings = s.split(" ");
        return strings[strings.length-1].trim().length();
    }
1
2
3
4
5
6
7
8

66、加一
给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

//(垃圾解法）
public int[] plusOne(int[] digits) {
        int[] result = new int[digits.length + 1];
        result[digits.length] = digits[digits.length - 1] + 1;
        for (int i=digits.length-1; i>0; i--){
            result[i] = digits[i-1];
        }
        for (int i = result.length - 1; i > 0; i--) {
            if (result[i] > 9) {
                result[i] = 0;
                result[i - 1] += 1;
            }
        }

        if (result[0] == 0) {
            int index = 0;
            for (int i=1; i<result.length; i++) {
                digits[index++] = result[i];
            }
            return digits;
        }
        return result;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

100、相同的树
给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

public boolean isSameTree(TreeNode p, TreeNode q) {
        if(p == null && q == null) {
            return true;
        }
        if(p == null || q == null) {
            return false;
        } 
        if(p.val != q.val) {
            return false;
        }
        return isSameTree(p.right, q.right) && isSameTree(q.left, p.left);
    }
1
2
3
4
5
6
7
8
9
10
11
12

970、强整数
给定两个正整数 x 和 y，如果某一整数等于 x^i + y^j，其中整数 i >= 0 且 j >= 0，那么我们认为该整数是一个强整数。

返回值小于或等于 bound 的所有强整数组成的列表。

你可以按任何顺序返回答案。在你的回答中，每个值最多出现一次。

public List<Integer> powerfulIntegers(int x, int y, int bound) {
        Set<Integer> set = new HashSet();
        // 2的21次方远远大于10的6次方
        for (int i=0; i<21; i++) {
            for (int j=0; j<21; j++) {
                int z = (int)(Math.pow(x,i) + Math.pow(y,j));
                //小于等于bound的都可以
                if (z <= bound) {
                    set.add(z);
                }
            }
        }
        return new ArrayList(set);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

976、三角形的最大周长
给定由一些正数（代表长度）组成的数组 A，返回由其中三个长度组成的、面积不为零的三角形的最大周长。

如果不能形成任何面积不为零的三角形，返回 0。

public int largestPerimeter(int[] A) {
        int p = 0;
        Arrays.sort(A);
        //至少需要3条边  所以i至少保留3个
        for (int i=A.length-1; i>=2; i--) {
            if ((A[i-1] + A[i-2]) > A[i]){
                p = A[i-1] + A[i-2] + A[i];
                break;
            }
        }
        return p;
    }
1
2
3
4
5
6
7
8
9
10
11
12

977、有序数组的平方
给定一个按非递减顺序排序的整数数组 A，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。

public int[] sortedSquares2(int[] A) {
        int len = A.length;
        int[] result = new int[len];
        int j=0;
        //j指向第一个非负数
        while (j<len && A[j] < 0) {
            j++;
        }
        int i = j-1;
        int t = 0;
        //i一直移动到最小的负数  j移动到最大的正数  或者有一个到边界
        while (i>=0 && j<len) {
            if (A[i] * A[i] < A[j] * A[j]) {
                result[t++] = A[i] * A[i];
                i--;
            } else {
                result[t++] = A[j] * A[j];
                j++;
            }
        }
        //剩余负数
        while (i>=0) {
            result[t++] = A[i] * A[i];
            i--;
        }
        //剩余正数
        while (j<len) {
            result[t++] = A[j] * A[j];
            j++;
        }
        return  result;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

1002、查找常用字符
给定仅有小写字母组成的字符串数组 A，返回列表中的每个字符串中都显示的全部字符（包括重复字符）组成的列表。例如，如果一个字符在每个字符串中出现 3 次，但不是 4 次，则需要在最终答案中包含该字符 3 次。

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

public List<String> commonChars(String[] A) {
        List<String> list = new ArrayList();
        List<List<String>> lists = new ArrayList<>();
        for (int i=1; i<A.length; i++) {
            char[] c = A[i].toCharArray();
            List l = new ArrayList();
            for (int j=0; j<c.length; j++) {
                l.add(c[j]);
            }
            lists.add(l);
        }

        char[] c = A[0].toCharArray();

        for (int i=0; i<c.length; i++) {
            boolean flag = true;
            for (int j=0; j<lists.size(); j++) {
                if (!lists.get(j).contains(c[i])) {
                    flag = false;
                }else {
                    lists.get(j).remove((Object)c[i]);
                }
            }
            if (flag) {
                list.add(String.valueOf(c[i]));
            }
        }
        return list;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29