Leetcode100题

1 两数之和

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

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

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

（1）hash表法

将数组的值为key，下标为value存入hashmap，依次向后遍历，判断（target-当前下标元素的值）是否存在于hashmap中，如果存在，则找到。

class Solution {
    public int[] twoSum(int[] nums, int target) {
       int len=nums.length;
        HashMap<Integer, Integer> map = new HashMap<>(len);
//        将数组的值为key，下标为value存入hashmap
        map.put(nums[0],0);
        for (int i = 1; i <len ; i++) {
            if (map.containsKey(target-nums[i])){
                return new int[]{i,map.get(target-nums[i])};
            }else {
                map.put(nums[i],i);
            }
        }
        throw new IllegalArgumentException("不存在");
    }
}

2 两数相加

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

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

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

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

 public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
//        创建一个新的链表存放结果
        ListNode head = null, tail = null;
//        代表进位的数字，初始是0；
        int carray = 0;
//        选择|| 是因为 当两数长短不一致时，长的那个的每一位数还要继续和0相加。
        while (l1 != null || l2 != null) {
//            l1=[5,2,3]  从左边开始取出第一个数
            int a = l1 != null ? l1.val : 0;
//            l2=[7,2,3]  从左边开始取出第一个数
            int b = l2 != null ? l2.val : 0;
//            sum=12;
            int sum = a + b + carray;
//            结果链表存在头尾指针
            if (head == null) {
                head = tail = new ListNode(sum % 10);
            } else {
                tail.next = new ListNode(sum % 10);
                tail = tail.next;
            }
//            carray=1
            carray = sum / 10;
            if (l1 != null) l1 = l1.next;
            if (l2 != null) l2 = l2.next;
        }
//        如果l1,l2位数相等并且最后两位相加有进位,才会执行
        if (carray > 0) {
            tail.next = new ListNode(carray);
        }
        return head;
    }

3 无重复字符的最长子串

滑动窗口方法

 public static int  lengthOfLongestSubString(String string){
//        字符串长度
        int len=string.length();
//        最长子串长度 ，初始值为0；
        int max=0;
//        滑动窗口的前指针位置
        int left=0;
//        hash的key为字符串中遍历的某个字符，value为当前字符的下标
        HashMap<Character, Integer> map = new HashMap<Character,Integer>();
        for (int i = 0; i < len; i++) {
//            判断当前字符是否存在于map中，如果存在,就将value（字符的下标）+1，然后和旧的left比较去最大值。
            if (map.containsKey(string.charAt(i))){
                left=Math.max(left,string.charAt(i)+1);
            }
//            将当前字符存入字典
            map.put(string.charAt(i),i);
//            获取子串长度为滑动窗口的左右边界+1
            max=Math.max(max,i-left+1);
        }
        return max;
    }

注意：字符串可能是这样的 --> “ abbac”。按照我们的方法，会先将ab存入到我们的map当中，此时left = 0，当i=2时，由于map中已经有b，因此left将等于get(b) + 1 = 2。随后i指针向后指去又遇到map已有元素a，按照前面的算法，此刻left = get(a) + 1 = 1,但实际上left不会变，仍然等于2，因此在求left值时总应该取最大的那个。