LeetCode 1-3题精讲

import java.util.HashMap;
import java.util.Map;
//给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
//
//你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
//
//示例:
//给定 nums = [2, 7, 11, 15], target = 9
//
//因为 nums[0] + nums[1] = 2 + 7 = 9
//所以返回 [0, 1]
//我们会遍历数组a,然后看除了a数组中有没有target-a的数,这样就能保证该数组有两个数和等于target
public class Suanfa1 {


        public int[] twoSum(int[] nums, int target) {
            int[] result = new int[2];
            HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
            for (int i = 0; i < nums.length; i++){
                if (map.containsKey(target - nums[i])){ //MAP里是否存在KEY
                    result[1] = i ;
                    result[0] = map.get(target - nums[i]);
                    return result;
                }
                map.put(nums[i],i);
            }
            return result;

        }

}

//给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
//
//如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
//
//您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
//
//示例:
//输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
//输出：7 -> 0 -> 8
//原因：342 + 465 = 807
//思路:
//模拟过程
//
//关键要处理进位的问题
//
//一位数和一位数相加,大于10时候,除以10,商为进位数,余数为该位的数.
//
//时间复杂度:
public class Suanfa2 {
    //定义一个链表，指针指向下一个链表
    public static class ListNode {
        int val; //值
        ListNode next; //指针
        ListNode(int x) { val = x; }
    }

    //l1和l2俩个链表的节点相加后，放入第三个链表，最后返回第三个链表的对象
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode(0);//定义一个0链表节点
        ListNode p = dummy;
        int carry_digit = 0;
        while (l1 != null || l2 != null || carry_digit != 0){ //循环
            int tmp = (l1!=null?l1.val:0)+(l2!=null?l2.val:0)+carry_digit; //俩个链表l1和l2的值相加,再加上商数
            carry_digit = tmp / 10; //求商数
            p.next = new ListNode(tmp%10); //求余数，余数作为val;每一轮循环，next指定一个ListNode节点

            //向下位移操作,计算链表的下一个节点
            p = p.next; //p节点向下移位
            l1 = l1 != null ? l1.next:l1; //l1节点向下移位，null了就不向下移位了
            l2 = l2 != null ? l2.next:l2; //l2节点向下移位，null了就不向下移位了
        }
        return dummy.next;
    }
}

 

//给定一个字符串，请你找出其中不含有重复字符的 最长MAX子串 的长度。
//示例:
//示例 1:
//
//输入: "abcabcbb"
//输出: 3
//解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
//示例 2:
//
//输入: "bbbbb"
//输出: 1
//解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
//示例 3:
//
//输入: "pwwkew"
//输出: 3
//解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
//     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
//思路:
//这道题主要用到思路是: 滑动窗口
//
//什么是滑动窗口?
//
//其实就是一个队列,比如例题中的abcabcbb,当进入这个队列(窗口)为abc满足题目要求,当再进字母入a,队列变成了abca,这时候不满足要求,所以,我们要移动这个队列!
//
//如何移动?
//
//我们只要把队列的左边的元素移出就行了,直到满足题目要求!
//
//一直维持这样的队列,找出队列出现最长的长度时候,求出解!

import java.util.HashMap;
//如果重复添加的话,hashmap会自动覆盖key一样的数据,保证一个key对应一个value
//1、先利用重复key覆盖的性质，遍历字符串每个字符并插入hashmap.得到一个没有重复key的集合
//2、
public class Suanfa3 {
    //s=abcdeadfgy
    public int lengthOfLongestSubstring(String s) {
        if (s.length()==0) return 0;
        //hashmap的key 是字符，value是下标
        HashMap<Character, Integer> map = new HashMap<Character, Integer>();
        int max = 0;
        int leftMax = 0;
        for(int i = 0; i < s.length(); i ++){
            //查找hashmap当前元素存在，则计数
            if(map.containsKey(s.charAt(i))){
                //s.charAt(i) 取下标5的字符是a
                //map.get(s.charAt(i))取map里a的value是0
                //left=最大的下标是1

                //第二轮，s.charAt(i)取下标6的字符是d
                //map.get(s.charAt(i))取map里d的value是3
                //left=最大的下标是3+1=4
                leftMax = Math.max(leftMax,map.get(s.charAt(i)) + 1); //最边找到不重复子串的最大下标值
            }
            map.put(s.charAt(i),i);
            //第一轮，5-1+1=5，或者max的最大，就是结果5
            //第二轮，6-4+1=3,小于5，结果还是5
            //最大长度减去不重复的位置left,计算右边最大的，左边最大和右边最大的其一最大就是结果。
            //第三轮，7-4+1=4
            //第四轮，8-4+1=5
            //第五轮,9-4+1=6
            // i-leftMax+1 是找到右边不重复的子串最大下标值
            max = Math.max(max,i-leftMax+1);
        }
        return max; //本题最终结果是6，是这个eadfgy大小是6，abcde大小是5

    }
}

 

import java.util.Arrays;

public class SuanfaMain {
    public static void main(String[] args) {
//1
        int a[] = { 49, 35, 65, 97, 76, 13, 27, 49 };
        int[] rs=new Suanfa1().twoSum(a,100);
        System.out.println(Arrays.toString(rs));
//2
        Suanfa2.ListNode a1=new Suanfa2.ListNode(2);
        Suanfa2.ListNode a2=new Suanfa2.ListNode(4);
        Suanfa2.ListNode a3=new Suanfa2.ListNode(3);

        a1.next=a2;
        a2.next=a3;

        Suanfa2.ListNode b1=new Suanfa2.ListNode(5);
        Suanfa2.ListNode b2=new Suanfa2.ListNode(6);
        Suanfa2.ListNode b3=new Suanfa2.ListNode(4);

        b1.next=b2;
        b2.next=b3;

        Suanfa2.ListNode c1=new Suanfa2().addTwoNumbers(a1,b1);

        System.out.println(c1.val+""+c1.next.val+""+c1.next.next.val);
        //3
        Suanfa3 suanfa3=new Suanfa3();
        int x=suanfa3.lengthOfLongestSubstring("abcdeadfgy");
        System.out.println(x);
    }
}