LeetCode 查找类题目

4. Median of Two Sorted Arrays

题意：查找两个有序数组的中位数。

思路：通过查找第k个数的方法来找中位数，对于A、B两个数组，如果A[k/2]>B[k/2]那么两个数组并集的中位数肯定不在B的前k/2个元素中，所以可以删掉一部分数，反之亦可，最后剩下的就是所求的中位数。具体见代码。

参考：http://blog.youkuaiyun.com/gao1440156051/article/details/51725845

class Solution {  
public:  
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {  
        // write your code here  
        int len1=nums1.size();  
        int len2=nums2.size();  
        int len=len1+len2;  
        if(len & 1){  
            return findKth(nums1,0,nums2,0,len/2+1);  //总数为奇数，返回中间的数
        }  
        return (findKth(nums1,0,nums2,0,len/2)+findKth(nums1,0,nums2,0,len/2+1))/2;//总数为偶数，返回中间两个数的和除以2  
    }  
  
    double findKth(vector<int>& nums1,int i1,vector<int>& nums2,int i2,int k){  
        if(i1>=nums1.size()){  
            return nums2[i2+k-1];  //说明不在nums1的数组里，直接去nums2数组找
        }  
        if(i2>=nums2.size()){  
            return nums1[i1+k-1];  
        }  
        if(k==1){  
            return min(nums1[i1],nums2[i2]);  //返回最小的那个
        }  
  
        int key1=i1+k/2-1>=nums1.size()?INT_MAX:nums1[i1+k/2-1];  
        int key2=i2+k/2-1>=nums2.size()?INT_MAX:nums2[i2+k/2-1];  
        if(key1<key2){  
            return findKth(nums1,i1+k/2,nums2,i2,k-k/2);  //根据之前的分析缩小查找范围
        }else{  
            return findKth(nums1,i1,nums2,i2+k/2,k-k/2);  
        }  
    }
};  

41. First Missing Positive

题意：给出一个数组找到第一个不存在的自然数。

思路：由于要求在常量空间，只能利用原有数组，第i个位置对应的数应该为i+1，例如A[0]=1,A[1]=2,如果不符合，就将A[i]和A[A[i] - 1]交换，直到把正确的数换到相应的位置或者超出了数组范围，最后遍历数组，第一个不符合的就是缺失的正整数。

class Solution {
public:
    int firstMissingPositive(vector<int>& A) {
        int n=A.size();
         for(int i = 0; i < n; ++ i)
            while(A[i] > 0 && A[i] <= n && A[A[i] - 1] != A[i])
                swap(A[i], A[A[i] - 1]);
        
        for(int i = 0; i < n; ++ i)
            if(A[i] != i + 1)
                return i + 1;
        
        return n + 1;
    }
};

81. Search in Rotated Sorted Array II

题意：一个有序的数组在一个节点被旋转，在这样的数组里查找一个数。

思路：如果数组未被转置，很容易想到二分法，但是旋转过也可以用二分法，就是多考虑几种情况，来判断当前区间数组是递增还是递减的。如果nums[mid]==target，直接返回，如果nums[left]<nums[mid]，这时候还不能确定数组方向，再加上条件nums[left]<=target和nums[mid]>target,则说明target可能出现在[left,mid]之间      例如：arr={1 ,2, 3, 4 ,5} target=2，依次类推。

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        if(nums.empty()) return false;
        int left=0,right=nums.size()-1;
        while(left<=right)
        {
            int mid=(left+right)/2;
            if(nums[mid]==target)
                return true;
            if(nums[left]<nums[mid])
            {
                if(nums[left]<=target && nums[mid]>target)
                    right=mid-1;
                else
                    left=mid+1;
            }
            else if(nums[left]>nums[mid])
            {
                if(nums[mid]<target && nums[right]>=target)
                    left=mid+1;
                else
                    right=mid-1;
            }
            else 
                left++;
        }
        return false;
    }
};

153. Find Minimum in Rotated Sorted Array

题意：在旋转后的有序数组中找最小值。

思路：有序数组默认想到二分法，虽然经过旋转，但是两个区间分开是默认增长的，所以比较A[mid]和A[end]。如果A[mid]>A[end]，由于数组是递增的，所以mid和end肯定不在同一区间，mid最左边的数不可能小于mid最右边的数，因为数字不重复且递增，所以此时最小值再[mid+1,end]里；如果A[mid]<A[end]，如果[mid,end]区间递增，那么mid此时最小，或许还有更小的数在mid左边，此时right=mid。

class Solution {
public:
    int findMin(vector<int>& nums) {

         int left = 0, right = nums.size()-1;
        while(left < right) {
            int mid =  (right + left) / 2;
            if(nums[mid] < nums[right]){
                right = mid;
            }else{
                left = mid+1;
            }
        }
        return nums[left];
    }
};

179. Largest Number

题意：给出一个数组，组成最大的数（string类型）。

思路：既然要求最大的数字，肯定是依次把最大的数放在前面。如果直接用int型sort得到的排序不符合要求，可以想到string类型的排序就和所希望的排序一样。所以先将int型转化为string型，重写cmp函数，再依次加入。

注意：1.compare函数的重写。利用a+b<b+a，将小的放在前面。

            2.to_string将int型转为string。

class Solution {
public:
    static bool compare(string a, string b){
    return a+b<b+a; 
}
    string largestNumber(vector<int>& nums) {
      if (nums.empty()) return "";
    vector<string> num_str;
    for (int i=0;i<nums.size();i++){
        num_str.push_back(to_string(nums[i]));
    }
    sort(num_str.begin(),num_str.end(),compare);
    string res="";
    for (int i=nums.size()-1;i>=0;i--){
        res+=num_str[i];
    }
    if (compare("0",res)) return res;
    else return "0";
    }
};

179. Largest Number