leetcode解题记录

Practice 1:

题目描述：

给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。

你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。

示例：

给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

我的解答：

class Solution {
   public int[] twoSum(int[] nums, int target) {
        int [] array = nums;
        int sum = target;
        int second;
        int first;
        for (int i = 0; i < array.length; i++) {
            first = array[i];
            second = sum - first;
            for (int j = i+1; j <array.length ; j++) {
                if (second == array[j]){
                    return new int[] {i,j};
                }
            }
        }
        return null;
    } 
}

更优解答案解析：

两遍哈希表

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        map.put(nums[i], i);
    }
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement) && map.get(complement) != i) {
            return new int[] { i, map.get(complement) };
        }
    }
    throw new IllegalArgumentException("No two sum solution");
}

• 时间复杂度：O(n)， 我们把包含有 nn 个元素的列表遍历两次。由于哈希表将查找时间缩短到 O(1)) ，所以时间复杂度为 O(n)。

• 空间复杂度：O(n)， 所需的额外空间取决于哈希表中存储的元素数量，该表中存储了 n 个元素。 

 

Practice 2:

给定两个非空链表来表示两个非负整数。位数按照逆序方式存储，它们的每个节点只存储单个数字。将两数相加返回一个新的链表。

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

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)

输出：7 -> 0 -> 8

原因：342 + 465 = 807

我的解答：

这道题自己没有做出来，在看完解答后，按答案的方式做了一遍。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
     public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
         ListNode head = new ListNode(0);
         ListNode curr = head;
         ListNode p = l1;
         ListNode q = l2;
         int carry = 0;
         int sum = 0;
        while (p != null || q != null) {
            int x = (p!=null)?p.val:0;
            int y = (q!=null)?q.val:0;
            sum = x+y+carry;
            carry = sum/10;
            curr.next = new ListNode(sum%10);
            curr = curr.next;
            if(p!=null)
                p=p.next;
            if(q!=null)
                q=q.next;

        }
         if(carry>0){
             curr.next = new ListNode(1);
         }
         
    
        return head.next;
    }
}

 

Practice 3

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

示例：

给定 "abcabcbb" ，没有重复字符的最长子串是 "abc" ，那么长度就是3。

给定 "bbbbb" ，最长的子串就是 "b" ，长度是1。

给定 "pwwkew" ，最长子串是 "wke" ，长度是3。请注意答案必须是一个子串，"pwke" 是 子序列  而不是子串。

我的解答错误

答案解析：

（一）暴力法

逐个检查所有的子字符串，看它是否不含有重复的字符。

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        int n = s.length();
        int ans = 0;
        for (int i = 0; i < n; i++)
            for (int j = i + 1; j <= n; j++)
                if (allUnique(s, i, j)) ans = Math.max(ans, j - i);
        return ans;
    }

    public boolean allUnique(String s, int start, int end) {
        Set<Character> set = new HashSet<>();
        for (int i = start; i < end; i++) {
            Character ch = s.charAt(i);
            if (set.contains(ch)) return false;
            set.add(ch);
        }
        return true;
    }
}

（二）滑动窗口

 滑动窗口是数组/字符串问题中常用的抽象概念。 窗口通常是在数组/字符串中由开始和结束索引定义的一系列元素的集合，即 [i, j)左闭，右开）。而滑动窗口是可以将两个边界向某一方向“滑动”的窗口。例如，我们将 [i, j)向右滑动 1个元素，则它将变为 [i+1, j+1)（左闭，右开）。

使用 HashSet 将字符存储在当前窗口 [i, j)（最初 j = i）中。 然后我们向右侧滑动索引 j，如果它不在 HashSet 中，我们会继续滑动 j。直到 s[j] 已经存在于 HashSet 中。此时，我们找到的没有重复字符的最长子字符串将会以索引 i 开头。如果我们对所有的 i 这样做，就可以得到答案。

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        int n = s.length();
        Set<Character> set = new HashSet<>();
        int ans = 0, i = 0, j = 0;
        while (i < n && j < n) {
            // try to extend the range [i, j]
            if (!set.contains(s.charAt(j))){
                set.add(s.charAt(j++));
                ans = Math.max(ans, j - i);
            }
            else {
                set.remove(s.charAt(i++));
            }
        }
        return ans;
    }
}

优化滑动窗口

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        int n = s.length(), ans = 0;
        Map<Character, Integer> map = new HashMap<>(); // current index of character
        // try to extend the range [i, j]
        for (int j = 0, i = 0; j < n; j++) {
            if (map.containsKey(s.charAt(j))) {
                i = Math.max(map.get(s.charAt(j)), i);
            }
            ans = Math.max(ans, j - i + 1);
            map.put(s.charAt(j), j + 1);
        }
        return ans;
    }
}

 执行用时最短解法

class Solution {
    public int lengthOfLongestSubstring(String s) {
        if (s ==null || s.length() <1) return 0;
        int ret =0;
        char[] sAry = s.toCharArray();
        int[] pos = new int[256];
        
        for (int i=0, j=0; j <sAry.length; j++){
            i = Math.max(pos[sAry[j]] , i);
            ret = Math.max(ret, j-i+1);
            pos[sAry[j]] = j+1;
        }
        
        return ret;
    }
}

 Practice 4

题目描述

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2 。

请找出这两个有序数组的中位数。要求算法的时间复杂度为 O(log (m+n)) 。

我的解答 执行时间208ms

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int[] array=twoToOne(nums1,nums2);
        int n = array.length;
        if(n%2==1){
            return array[n/2];
        }else{
            return ((double)array[n/2-1]+(double)array[n/2])/2;
        }
        
    }
    
    public int[] twoToOne(int[] nums1,int[] nums2){
        int m = nums1.length;
        int n=nums2.length;
        int[] array=new int[m+n];
        int k=0;
        for(int i=0;i<m;i++){
           array[k++]=nums1[i];
        }
        for(int j=0;j<n;j++){
            array[k++]=nums2[j];
        }
        
        return sort(array);
        
    }
    
    public int[] sort(int[] array){
        int[] ary = array;
        int n = ary.length;
        for(int i = 0;i<n;i++){
            for(int j=1;j<n-i;j++){
                if(ary[i]>ary[i+j]){
                    int tmp = ary[i+j];
                    ary[i+j]=ary[i];
                    ary[i]=tmp;
                    
                }
            }
        }
        return ary;
    }
}

 

答案解析

然而答案并没有弄懂

class Solution {
    public double findMedianSortedArrays(int[] A, int[] B) {
        int m = A.length;
        int n = B.length;
        if (m > n) { // to ensure m<=n
            int[] temp = A; A = B; B = temp;
            int tmp = m; m = n; n = tmp;
        }
        int iMin = 0, iMax = m, halfLen = (m + n + 1) / 2;
        while (iMin <= iMax) {
            int i = (iMin + iMax) / 2;
            int j = halfLen - i;
            if (i < iMax && B[j-1] > A[i]){
                iMin = iMin + 1; // i is too small
            }
            else if (i > iMin && A[i-1] > B[j]) {
                iMax = iMax - 1; // i is too big
            }
            else { // i is perfect
                int maxLeft = 0;
                if (i == 0) { maxLeft = B[j-1]; }
                else if (j == 0) { maxLeft = A[i-1]; }
                else { maxLeft = Math.max(A[i-1], B[j-1]); }
                if ( (m + n) % 2 == 1 ) { return maxLeft; }

                int minRight = 0;
                if (i == m) { minRight = B[j]; }
                else if (j == n) { minRight = A[i]; }
                else { minRight = Math.min(B[j], A[i]); }

                return (maxLeft + minRight) / 2.0;
            }
        }
        return 0.0;
    }
}

 执行时间为38ms的代码范例

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        
           int n = nums1.length;
           int m = nums2.length;
           double re = 0;
           int t1=0;
           int t2=0;
           int p1=0;
           int p2=0;
           if((n+m)%2 == 1){
               for(int i = 0; i< (n+m)/2 + 1; i++){
                    if(p1<n && p2<m){
                        if(nums1[p1] > nums2[p2]){
                            t1 = nums2[p2];
                            p2++;
                        }else {
                            t1 = nums1[p1];
                            p1++;
                        }
                    }
                   else  if(p1<n ){
                           t1 = nums1[p1];
                           p1++;
                       }
                       else if(p2<m ){
                          t1 = nums2[p2];
                          p2++;
               }
               }
               return t1*1.0;
           }
           else {
               for(int i = 0; i< (n+m)/2; i++){
                   if(p1<n && p2<m){
                       if(nums1[p1] > nums2[p2]){
                           t1 = nums2[p2];
                           p2++;
                       }else {
                           t1 = nums1[p1];
                           p1++;
                       }
                   }
                   else  if(p1<n ){
                       t1 = nums1[p1];
                       p1++;
                   }
                   else if(p2<m ){
                       t1 = nums2[p2];
                       p2++;
                   }
               }
               if(p1<n && p2<m){
                   if(nums1[p1] > nums2[p2]){
                       t2 = nums2[p2];
                       p2++;
                   }else {
                       t2 = nums1[p1];
                       p1++;
                   }
               }
               else  if(p1<n ){
                   t2 = nums1[p1];
                   p1++;
               }
               else if(p2<m ){
                   t2 = nums2[p2];
                   p2++;
               }
               return (t1+t2)/2.0;

           }
    
        
    }
}

 Practice 5

题目描述

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为1000。

我的解答：

class Solution {
    public String longestPalindrome(String s) {
        //find all sub string 
        String  result=null;
        if(s==""){
            return "can not be empty.";
        }
        
        char[] str = s.toCharArray();
        int n = str.length;
        if(n==1){
            return s;
        }
        int len = 1;
        for(int i=0;i<n;i++){
            StringBuilder sBuilder = new StringBuilder(); 
            sBuilder.append(str[i]);
            
            for(int j=i+1;j<n;j++){
                sBuilder.append(str[j]);
                String tmp =sBuilder.toString();
                if(isPalindrome(tmp)){
                    if(tmp.length()>=len){
                        len = tmp.length();
                        result=tmp;
                    }
                }
            }
        }
        
        if(result==null){
            return String.valueOf(str[0]);
        }else{
            return result;
        }
    }
    
    public boolean isPalindrome(String s){
        char[] str= s.toCharArray();
        int n = str.length;
        for(int i=0;i<n/2;i++){
            if(str[i]!=str[n-i-1]){
                return false;
            }
        }
        return true;
    }
}

提交后测试用例通过79个，第80个超出时间限制。

答案解析:

中心扩展算法

回文中心的两侧互为镜像。因此，回文可以从它的中心展开，并且只有 2n - 1 个这样的中心。

你可能会问，为什么会是 2n - 1 个，而不是 nn 个中心？原因在于所含字母数为偶数的回文的中心可以处于两字母之间。

例如“abba”的中心在两个‘b’之间。

public String longestPalindrome(String s) {
    int start = 0, end = 0;
    for (int i = 0; i < s.length(); i++) {
        int len1 = expandAroundCenter(s, i, i);
        int len2 = expandAroundCenter(s, i, i + 1);
        int len = Math.max(len1, len2);
        if (len > end - start) {
            start = i - (len - 1) / 2;
            end = i + len / 2;
        }
    }
    return s.substring(start, end + 1);
}

private int expandAroundCenter(String s, int left, int right) {
    int L = left, R = right;
    while (L >= 0 && R < s.length() && s.charAt(L) == s.charAt(R)) {
        L--;
        R++;
    }
    return R - L - 1;
}