leetCode(java)_leetcode java

TowSum

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

1. 创建一个map
2. for循环遍历nums数组
3. 用target - nums[i],用来计算那个数跟当前的数字相加得到target
4. 检查map中是否有这个数,如果有则返回结果,如果没有则把num[i]当做key,i当做value放入map中

package wanan;


import java.util.HashMap;
import java.util.Map;

public class TwoSum {
    public int[] twoSum(int[] nums,int target){
//        返回值为int[]数组
        HashMap<Integer, Integer> map = new HashMap<>();
//        定义一个hashmap
        for(int i = 0;i<nums.length;i++){
//            循环遍历数组每一个值
            int complement = target - nums[i];
//            使用目标 - 取到的值
            if (map.containsKey(complement) && map.get(complement) != i){
//                如果map中存在这个键 并且这个值不等于它本身
                return new int[]{i, map.get(complement)};
//                如果找到了就放入答案中
            }else {
                map.put(nums[i],i);
//                没找到就将键值放入map中
            }
        }
//        如果循环完成还没return就返回空数组
        return new int[0];


    }
}

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

AddTwoNumbers

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

package wanan;
class  ListNode{
    public int val;
//    节点的保存内容
    public ListNode next = null;
//      节点的引用,指向下一个节点
    public ListNode(int val){
        this.val = val;
    }
}

public class AddTwoNumbers {
    public ListNode addTwoNumbers(ListNode l1,ListNode l2){
//        返回一个链表
        ListNode dummy = new ListNode(0);
//定义一个哑结点
        ListNode curr = dummy;
//        定义一个新链表
        int carry = 0;
//        定义进位
        while(l1 != null || l2 != null){
//            如果l1和l2都不等于null
            int sum = 0;
//            定义和为0
            if(l1 != null){
                sum += l1.val;
//                和等于l1的值
                l1 = l1.next;
//                l1变成下一个节点

            }
            if (l2 !=null){
                sum += l2.val;
//                l2也加上
                l2 = l2.next;
//                l2指向下一个


            }
            sum += carry;
            curr.next = new ListNode(sum % 10);
//            新链表的下一个值为和取模 就是从这里放进去的
            carry = sum / 10;
//            得到进位
            curr = curr.next;

        }
//        这里前面已经循环完成了作为最后一次循环判断有无进位
        if (carry > 0){
            curr.next = new ListNode(carry);
        }
        return  dummy.next;
    }
}

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

LengthOfLongestSubstring

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

package wanan;

import java.util.HashSet;

public class LengthOfLongestSubstring {
    public int lengthOfLongestSubstring(String s){
//        返回一个int
        HashSet<Character> set = new HashSet<>();
//        定义一个hashset其中值全部为字母
        int j = 0,maxLength = 0;
//        定义j指针 和 maxLangth标识符
        if(s == null|| s.length() == 0){
//            如果传入的字符串啥也没有就返回0
            return 0;
        }
        for(int i= 0;i<s.length();i++){
            if (!set.contains(s.charAt(i))){
//                如果在set中不存在这个字符的话就将这个字符添加进set中去
                set.add(s.charAt(i));
                maxLength = Math.max(maxLength, set.size());
//                比较maxLeng和set的长度将其中最大的赋值给maxLength

            }else {
                while (set.contains(s.charAt(i))){
//                    这里使用while是为了当有多个重复的值都需要移除出去
//                    如果set中存在这个字符,那么就将它移除出入
                    set.remove(s.charAt(j));
                    j++;
//                    更改j指向的值

                }
//                移除完成之后将i的值添加进set中
                set.add(s.charAt(i));
            }
        }
        return maxLength;
    }
}

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
33
34
35
36
37
38
39

LongestPalindromicSubstring

给你一个字符串 s，找到 s 中最长的回文子串。

package wanan;

class LongestPalindromicSubstring{
    private int start =0 ,maxLength = 1;
//    定义开始下标 和最大长度
    public String longestPalindrome(String s){
        if (s.length() < 2){
//        如果s的长度只有1个的话就直接返回s
            return s;
        }


        for (int i= 0;i <s.length();i++){
//            对每一个字母都进行循环并且循环两边
            expandAroundCenter(s,i -1,i+1);
            expandAroundCenter(s,i ,i+1);
        }
        return s.substring(start,start+maxLength);
//        循环完成之后返回这个字符串

    }
    private void expandAroundCenter(String s,int left,int right){
//        定义寻找方法用于寻找最长的
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)){
//            如果没有下标越界问题并且两个字母相等的话
            if (right - left +1 > maxLength){
//                判断一下最大长度是那个
                maxLength = right - left +1;
                start = left;
            }
            left -- ;
            right ++;

        }
    }


}
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
33
34
35
36
37
38

ThreeSum

package wanan;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

class ThreeSum{
    public List<List<Integer>> threeSum(int[] nums){
//        返回一个列表内容是一个列表
        ArrayList<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
//先对目标进行排序
        for (int i=0 ;i < nums.length -2 ;i++){
//            对数组进行循序

            if ( i== 0 || nums[i] != nums[i - 1]){
//                用于判断当前的i 和上一个i-1是否相同目的是去除重复

                int start = i +1 , end = nums.length - 1;
//                定义开始 和结束

                while (start < end) {
//                    当开始小于结束的时候

                    if (nums[i] + nums[start] + nums[end] == 0) {
//                        如果等于0 就放进去
                        result.add(Arrays.asList(nums[i], nums[start], nums[end]));
//                        向后移动
                        start++;
                        end--;
//                      这里也是为了去重,原因是这个值和前一个是相同的
                        while (start < end && nums[start] == nums[start - 1]) {
                            start++;
                        }
//                        去重
                        while (start < end && nums[end] == nums[end + 1]) {
                            end--;
                        }

//                  如果小于零就向后移动
                    } else if (nums[i] + nums[start] + nums[end] < 0) {
                        start++;
                    } else {
                        end--;
                    }
                }
            }
        }
        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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51