LeetCode(一)

数据流的中位数

class MedianFinder {
    private Queue<Integer> maxHeap = new PriorityQueue(new Comparator<Integer>(){
       @Override
       public int compare(Integer i1, Integer i2){
           return Integer.compare(i2, i1);
       }
    });
    private Queue<Integer> minHeap = new PriorityQueue(new Comparator<Integer>(){
       @Override
       public int compare(Integer i1, Integer i2){
           return Integer.compare(i1, i2);
       }
    });

    // Adds a number into the data structure.
    public void addNum(int num) {
        minHeap.offer(num);
        maxHeap.offer(minHeap.poll());

        //if(maxHeap.size() > minHeap.size())
        if(maxHeap.size() - minHeap.size() == 1){
            minHeap.offer(maxHeap.poll());
        }
    }

    // Returns the median of current data stream
    public double findMedian() {
        return minHeap.size() > maxHeap.size()
             ? (double)minHeap.peek()
             : (minHeap.peek() + maxHeap.peek())/2.0;
    }
};

两个已排序数组的中位数

public class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int m = nums1.length;
        int n = nums2.length;
        int mid1 = (m+n+1)/2;
        int mid2 = (m+n+2)/2;
        return (findKthNum(nums1,0,nums2,0,mid1) + findKthNum(nums1,0,nums2,0,mid2))/2.0;
    }
    public int findKthNum(int[] nums1,int start1,int[] nums2,int start2,int k){
        if(start1>nums1.length-1){return nums2[start2+k-1];}
        if(start2>nums2.length-1){return nums1[start1+k-1];}
        if(k==1) return Math.min(nums1[start1],nums2[start2]);
        int mid1 = Integer.MAX_VALUE,mid2=Integer.MAX_VALUE;
        if(nums1.length-start1+1>k/2){mid1 = nums1[start1+k/2 - 1];}
        if(nums2.length-start2+1>k/2){mid2 = nums2[start2+k/2 - 1];}
        if(mid1<mid2){
            return findKthNum(nums1,start1+k/2,nums2,start2,k-k/2);
        }else{
            return findKthNum(nums1,start1,nums2,start2+k/2,k-k/2);
        }
    }
}

旋转数组中找到最小的数字

public class Solution {
    public int findMin(int[] nums) {
        int len = nums.length;
        int l=0;
        int r=len-1;
        while(l<r){
            if(nums[l]<nums[r]){return nums[l];}
            int mid = l + (r-l)/2;
            if(nums[mid]>nums[r]){
                l = mid + 1;
            }else if(nums[mid]<nums[r]){
                r = mid;
            }else{
                r--;
            }
        }
        return nums[l];
    }
}

旋转数组中搜索一个数字

public class Solution {
    public boolean search(int[] nums, int target) {
        int start = 0, end = nums.length - 1, mid = -1;
        while(start <= end) {
            mid = (start + end) / 2;
            if (nums[mid] == target) {
                return true;
            }
            //If we know for sure right side is sorted or left side is unsorted
            if (nums[mid] < nums[end] || nums[mid] < nums[start]) {
                if (target > nums[mid] && target <= nums[end]) {
                    start = mid + 1;
                } else {
                    end = mid - 1;
                }
            //If we know for sure left side is sorted or right side is unsorted
            } else if (nums[mid] > nums[start] || nums[mid] > nums[end]) {
                if (target < nums[mid] && target >= nums[start]) {
                    end = mid - 1;
                } else {
                    start = mid + 1;
                }
            //If we get here, that means nums[start] == nums[mid] == nums[end], then shifting out
            //any of the two sides won't change the result but can help remove duplicate from
            //consideration, here we just use end-- but left++ works too
            } else {
                end--;
            }
        }

        return false;
    }
}

归并两个排序链表

public class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1==null||l2==null) return l1==null?l2:l1;
        ListNode head = null;
        if(l1.val<=l2.val) {
            head=l1;
            l1=l1.next;
        }
        else {
            head=l2;
            l2=l2.next;
        }
        ListNode temp = head;
        while(l1!=null&&l2!=null){
            if(l1.val<=l2.val) {
                temp.next=l1;
                l1=l1.next;
            }
            else {
                temp.next=l2;
                l2=l2.next;
            };
            temp=temp.next;
        }
        temp.next=l1==null?l2:l1;
        return head;
    }
}

归并K个排序链表

public class Solution {
    public static ListNode mergeKLists(ListNode[] lists){
        return partion(lists,0,lists.length-1);
    }

    public static ListNode partion(ListNode[] lists,int s,int e){
        if(s==e)  return lists[s];
        if(s<e){
            int q=(s+e)/2;
            ListNode l1=partion(lists,s,q);
            ListNode l2=partion(lists,q+1,e);
            return merge(l1,l2);
        }else
            return null;
    }

    //This function is from Merge Two Sorted Lists.
    public static ListNode merge(ListNode l1,ListNode l2){
        if(l1==null) return l2;
        if(l2==null) return l1;
        if(l1.val<l2.val){
            l1.next=merge(l1.next,l2);
            return l1;
        }else{
            l2.next=merge(l1,l2.next);
            return l2;
        }
    }
}

寻找重复数字,O(N),O(1)

参考：Find the Duplicate Number

public class Solution {
    public int findDuplicate(int[] nums) {
        int slow = 0;
        int fast = 0;
        do{
            slow = nums[slow];
            fast = nums[nums[fast]];
        }while(slow!=fast);
        int find = 0;
        do{
            slow = nums[slow];
            find = nums[find];
        }while(slow!=find);
        return find;
    }
}

第一个不存在的正数

public class Solution {
    public int firstMissingPositive(int[] nums) {
        int n= nums.length;
        for(int i=0;i<n;){
            if(nums[i]>0 && nums[i]<=n && nums[i]!=nums[nums[i]-1]){
                swap(nums,i,nums[i]-1);
            }else{
                i++;
            }
        }
        int j=0;
        for(j=0;j<n;j++){
            if(j+1 != nums[j]){
                return j+1;
            }
        }
        return n+1;
    }
    public void swap(int[] nums,int i,int j){
        int tmp = nums[j];
        nums[j] = nums[i];
        nums[i] = tmp;
    }
}

KMP算法

class Solution {
public:
void getNext(vector<int> &next,string &needle){
int i=0,j=-1;
next[i] = j;
while(i<needle.size()-1){
while(j != -1 && needle[i]!=needle[j]){
j = next[j];
}
i++;
j++;
if(needle[i] == needle[j]) next[i]=next[j];
else next[i] = j;
}
}
int strStr(string haystack, string needle) {
if (haystack.empty()) return needle.empty() ? 0 : -1;
if (needle.empty()) return 0;
vector<int> next(needle.size()+1);
getNext(next,needle);
int i=0,j=0;
while(i != haystack.size()){
while(j!=-1 && haystack[i] != needle[j]){j=next[j];}
i++;
j++;
if(j == needle.size()) return i-j;
}
return -1;
}
};

寻找数列的峰点(比两边数字都大的点)

public class Solution {
    public int findPeakElement(int[] num) {
        return helper(num,0,num.length-1);
    }
    public int helper(int[] num,int start,int end){
        if(start == end){
            return start;
        }else if(start+1 == end){
            if(num[start] > num[end]) return start;
            return end;
        }else{
            int m = (start+end)/2;
            if(num[m] > num[m-1] && num[m] > num[m+1]){
                return m;
            }else if(num[m-1] > num[m] && num[m] > num[m+1]){
                return helper(num,start,m-1);
            }else{
                return helper(num,m+1,end);
            }
        }
    }
}

​