Leetcode单排上分日记

在这里记录我刷题时候的思路，因为leetcode的编辑器就算是会员也不存档，

解答中也没有注释，长此以往做一道忘一道，所以在这里记录下

1. 两数之和（简单）

（java）

class Solution {
    public int[] twoSum(int[] nums, int target) {
        //定义这个数组是为了将nums中的第i个元素nums[i]的值nums[i]和位置i记录下来
        // 因为map的key是不重复的，所以在这里把nums[i]作为key存入
        // 这样再通过map.containsKey去查就是O(1)时间复杂度
        // 而且这些算法题很讲究两件事情同时做
        HashMap<Integer, Integer> map= new HashMap<Integer, Integer>();
        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);
        }
        return new int[0];
    }
}

 

2.两数相加（中等）

（java）

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        //读完题，不慌不慌，先设置两个元素存头节点和尾节点
        ListNode head = null, end = null;
        //进位，实际上不能超过1，因为两个个位数相加不会超过20
        int carry = 0;
        // 如何循环链表，这就是示范
        while(l1 != null || l2 != null){
            //非空则取值
            int n1 = l1 != null ? l1.val : 0;
            int n2 = l2 != null ? l2.val : 0;
            int sum = n1 + n2 + carry;
            //接下来就是扩展链表的方法了
            if(head == null){
                head = end = new ListNode(sum%10);
            }else{
                //在end之后插入一个节点，此时end不是尾节点了
                end.next = new ListNode(sum%10);
                //将end节点向后移动，使end真正成为尾节点
                end = end.next;
            }
            carry = sum/10;
            //类似于for循环中i++的机制，这里是改变指针的位置，l1,l2都向尾节点移动一位
            if(l1 != null){
                l1 = l1.next;
            }
            if(l2 != null){
                l2 = l2.next;
            }
        }
        if(carry > 0){
            end.next = new ListNode(carry);
        }
        //返回链表，从head节点（头节点）穿到end节点（尾节点）
        return head;
    }
}

3.无重复字符的最长字串（中等）

（java）(滑动窗口法)（滑动窗口还需研究）

class Solution {
    public int lengthOfLongestSubstring(String s) {
        // 哈希集合，记录每个字符是否出现过
        Set<Character> set = new HashSet<Character>();
        int n = s.length();
        // 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
        int rightIndex = -1, ans = 0;
        // 逐个字符循环字符串s
        for(int i = 0;i < n; ++i){
            if(i != 0){
                // 左指针向右移动一格，移除一个字符
                set.remove(s.charAt(i-1));
            }
            while(rightIndex + 1 < n && !set.contains(s.charAt(rightIndex + 1))){
                // 不断地移动右指针
                set.add(s.charAt(rightIndex + 1));
                ++rightIndex;
            }
            // 第 i 到 rk 个字符是一个极长的无重复字符子串
            ans = Math.max(ans, rightIndex - i + 1);
        }
        return ans;
    }
}

 

（java）(另一种时间复杂度更低的方法)

class Solution {
    public int lengthOfLongestSubstring(String s) {
        if(s.length() <= 1){
            return s.length();
        }

        int low = 0,max = 1;
        char m[] = s.toCharArray();
        for(int i = 1; i < m.length; i++){
            for(int j = low; j < i; j++){
                if(m[i] == m[j])
                {
                    low = j + 1;
                    break;
                }
            }
            max = max > (i-low+1)? max : (i-low+1);
        }
        return max;
    }
}

 

 

 

4.寻找两个正序数组的中位数（困难）

（java）好难，先放着

 

5.最长回文子串（中等）

（java）