第14天--算法（Leetcode 1- 5）

1.两数之和

public int[] twoSum(int[] nums, int target) {

        HashMap<Integer,Integer> hm = new HashMap<>();

        int res[] = new int[2];

        for(int i = 0;i < nums.length;i ++) {

            if(hm.containsKey(target - nums[i])) {

                res[0] = i;

                res[1] = hm.get(target - nums[i]);

                break;

            }else {

                hm.put(nums[i],i);

            }

        }

        return res;

}

2.两数相加

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {

        ListNode l = new ListNode();

        ListNode cur = l;

        boolean isTen = false;

        while(l1 != null && l2 != null) {

            int num = l1.val + l2.val;

            if(isTen) {

                num ++;

            }

            if(num >= 10) {

                num -= 10;

                isTen = true;

            }else {

                isTen = false;

            }

            cur.next = new ListNode(num);

            cur = cur.next;

            l1 = l1.next;

            l2 = l2.next;

        }

        if(l1 != null) {

            cur.next = l1;

            while(l1 != null) {

                if(isTen) {

                    l1.val ++;

                }

                if(l1.val == 10) {

                    isTen = true;

                    l1.val = 0;

                }else {

                    isTen = false;

                    break;

                }

                l1 = l1.next;

            }

        }

        if(l2 != null) {

            cur.next = l2;

            while(l2 != null) {

                if(isTen) {

                    l2.val ++;

                }

                if(l2.val == 10) {

                    isTen = true;

                    l2.val = 0;

                }else {

                    isTen = false;

                    break;

                }

                l2 = l2.next;

            }

        }

        ListNode pre = l;

        cur = l.next;

        while(cur != null) {

            cur = cur.next;

            pre = pre.next;

        }

        if(l1 == null || l2 == null) {

            if(isTen) {

                pre.next = new ListNode(1);

            }

        }

        return l.next;

}

3.无重复字符的最长子串

public int lengthOfLongestSubstring(String s) {

        if(s == null || s.length() == 0) {

            return 0;

        }

        char s1[] = s.toCharArray();

        int map[] = new int[256];

        for(int i = 0;i < 256;i ++) {

            map[i] = -1;

        }

        int res = 0;

        int pre = -1;

        int curRes = 0;

        for(int i = 0;i < s1.length;i ++) {

            pre = Math.max(pre,map[s1[i]]);

            curRes = i - pre;

            res = Math.max(curRes,res);

            map[s1[i]] = i;

        }

        return res;

    }

4.寻找两个正序数组的中位数（O(logN)）

public double findMedianSortedArrays(int[] nums1, int[] nums2) {

　　 if((nums1 == null || nums1.length == 0) && (nums2 == null || nums2.length == 0)) {

　　　　return 0;

　　}　　

　　if(nums1 == null || nums1.length == 0) {

　　　　boolean isEven = (nums2.length & 1) == 0 ? true : false;

　　　　if(isEven) {

　　　　　　return (nums2[nums2.length / 2] + nums2[nums2.length / 2 - 1]) / 2.0;

　　　　}else {

　　　　　　return nums2[nums2.length / 2];

　　　　}

　　}else if(nums2 == null || nums2.length == 0) {

　　　　boolean isEven = (nums1.length & 1) == 0 ? true : false;

　　　　if(isEven) {

　　　　　　return (nums1[nums1.length / 2] + nums1[nums1.length / 2 - 1]) / 2.0;

　　　　}else {

　　　　　　return nums1[nums1.length / 2];

　　　　}

　　}

　　int length = nums1.length + nums2.length;

　　boolean isEven = (length & 1) == 0 ? true : false;

　　if(isEven) {

　　　　return (g(nums1,nums2,length / 2) + g(nums1,nums2,length / 2 + 1)) / 2.0;

　　}else {

　　　　return g(nums1,nums2,length / 2 + 1);

　　}

}

//求等长有序数组arr1，arr2中上中位数

public int f(int arr1[],int arr2[],int i1,int j1,int i2,int j2) {

　　int length = j1 - i1 + 1;

　　boolean isEven = (length & 1) == 0 ? true : false;

　　if(isEven) {

　　　　if(length == 2) {

　　　　　　if(arr1[j1] <= arr2[i2]) {

　　　　　　　　return arr1[j1];

　　　　　　}else if(arr2[j2] <= arr1[i1]) {

　　　　　　　　return arr2[j2];

　　　　　　}else if(arr1[i1] >= arr2[i2] && arr1[i1] <= arr2[j2]) {

　　　　　　　　return arr1[i1];

　　　　　　}else if(arr2[i2] >= arr1[i1] && arr2[i2] <= arr1[j1]) {

　　　　　　　　return arr2[i2];

　　　　　　}else {

　　　　　　　　return 0;

　　　　　　}

　　　　}

　　　　int arr1Mid = (j1 + i1) / 2;

　　　　int arr2Mid = (j2 + i2) / 2;

　　　　if(arr1[arr1Mid] == arr2[arr2Mid]) {

　　　　　　return arr1[arr1Mid];

　　　　}else if(arr1[arr1Mid] > arr2[arr2Mid]) {

　　　　　　return f(arr1,arr2,i1,arr1Mid,arr2Mid + 1,j2);

　　　　}else {

　　　　　　return f(arr1,arr2,arr1Mid + 1,j1,i2,arr2Mid);

　　　　}

　　}else {

　　　　int arr1Mid = (j1 + i1) / 2;

　　　　int arr2Mid = (j2 + i2) / 2;

　　　　if(length == 1) {

　　　　　　return Math.min(arr1[i1],arr2[i2]);

　　　　}

　　　　if(arr1[arr1Mid] == arr2[arr2Mid]) {

　　　　　　return arr1[arr1Mid];

　　　　}else if(arr1[arr1Mid] > arr2[arr2Mid]) {

　　　　　　if(arr2[arr2Mid] >= arr1[arr1Mid - 1]) {

　　　　　　　　return arr2[arr2Mid];

　　　　　　}else {

　　　　　　　　return f(arr1,arr2,i1,arr1Mid - 1,arr2Mid + 1,j2);

　　　　　　}

　　　　}else {

　　　　　　if(arr1[arr1Mid] >= arr2[arr2Mid - 1]) {

　　　　　　　　return arr1[arr1Mid];

　　　　　　}else {

　　　　　　　　return f(arr1,arr2,arr1Mid + 1,j1,i2,arr2Mid - 1);

　　　　　　}

　　　　}

　　}

}

//求不一定等长有序数组arr1，arr2中第k小个数

public int g(int arr1[],int arr2[],int k) {

　　int shorts[] = arr1.length <= arr2.length ? arr1 : arr2;

　　int longs[] = arr1.length > arr2.length ? arr1 : arr2;

　　if(k <= shorts.length) {

　　　　return f(arr1,arr2,0,k - 1,0,k - 1);

　　}else if(k > shorts.length && k <= longs.length) {

　　　　if(longs[k - shorts.length - 1] >= shorts[shorts.length - 1]) {

　　　　　　return longs[k - shorts.length - 1];

　　　　}else {

　　　　　　return f(shorts,longs,0,shorts.length - 1,k - shorts.length,k - 1);

　　　　}

　　}else {

　　　　if(shorts[k - longs.length - 1] >= longs[longs.length - 1]) {

　　　　　　return shorts[k - longs.length - 1];

　　　　}else if(longs[k - shorts.length - 1] >= shorts[shorts.length - 1]) {

　　　　　　return longs[k - shorts.length - 1];

　　　　}else {

　　　　　　return f(shorts,longs,k - longs.length,shorts.length - 1,k - shorts.length,longs.length - 1);

　　　　}

　　}

}

5.最长回文子串

public String longestPalindrome(String s) {

        if(s == null || s.length() == 0) {

            return "";

        }

        char manacherString[] = manacherString(s);

        int C = -1;

        int R = -1;

        int radis[] = new int[manacherString.length];

        int max = 0;

        for(int i = 0;i < manacherString.length;i ++) {

            radis[i] = R > i ? Math.min(R - i,radis[C * 2 - i]) : 1;

            while(i + radis[i] < manacherString.length && i - radis[i] > -1) {

                if(manacherString[i + radis[i]] == manacherString[i - radis[i]]) {

                    radis[i] ++;

                }else {

                    break;

                }

            }

            if(radis[i] > R) {

                R = radis[i];

                C = i;

            }

            max = Math.max(max,radis[i]);

        }

        char res[] = new char[max - 1];

        StringBuilder sb = new StringBuilder();

        for(int i = C - max + 2;i <= C + max - 2;i += 2) {

            sb.append(manacherString[i]);

        }

        return sb.toString();

    }

    public char[] manacherString(String s) {

        char str[] = s.toCharArray();

        char manacherString[] = new char[str.length * 2 + 1];

        for(int i = 0,index = 0;i < manacherString.length;i ++) {

            manacherString[i] = (i & 1) == 0 ? '#' : str[index ++];

        }

        return manacherString;

    }