算法第三周

4. Median of Two Sorted Arrays

There are two sorted arrays nums1 and nums2 of size m and n respectively.Find the 
median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).

目标：在两个已排序好的数组中找到中间值。

遍历两个数组，每次将当前最小值压入向量，最后根据数组大小的奇偶性返回中间值。

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        bool isEven=((nums1.size()+nums2.size())%2==0);
        if(nums1.size()==0&&nums2.size()==0)
            return 0;
            int Size=nums1.size()+nums2.size();
            int size1=0,size2=0;
            vector<int> nums;

                while(size1<nums1.size()&&size2<nums2.size())
                {
                    if(nums1[size1]<nums2[size2])
                    {
                        nums.push_back(nums1[size1]);
                        size1++;
                    }

                    else 
                    {
                        nums.push_back(nums2[size2]);
                        size2++;
                    }
                }

                while(size2<nums2.size())
                {
                    nums.push_back(nums2[size2]);
                    size2++;
                }
                while(size1<nums1.size())
                {
                    nums.push_back(nums1[size1]);
                    size1++;
                }



            if(isEven)
            {
                double result=(double)(nums[Size/2-1]+nums[Size/2])/2;
                return result;
            }

            else
            {
                double result=(double)nums[Size/2];
                return result;
            }

    }
};

29. Divide Two Integers

Divide two integers without using multiplication, division and mod operator.If it is overflow, return MAX_INT.

* 目标：在不调用乘法，除法，取余的情况下计算两个数相除的结果。

用“<<1”符号可代替乘法，申明变量temp等于除数，让temp每次乘2，看是否超过被除数，未超过则继续乘2，否则让被除数减去当前temp值，并重复上述步骤，同时记录商的值，直到余数小于除数。
注意：
1.重新声明除数和被除数为long long 型，避免溢出。
2.除数为零时，为溢出的情况，同时，当被除数为INT_MIN（-2147483648），除数为-1时也被判定为溢出，因为int类型无法表示+2147483648。
3.labs（）为长整型取绝对值函数

class Solution {
public:
    int divide(int dividend, int divisor) {
        if(divisor==0||(dividend == INT_MIN && divisor == -1))
            return INT_MAX;
        if(dividend==0)
            return 0;
        int sign = 1;
        if((dividend < 0) ^ (divisor < 0))        
            sign = -1;
        long long divid=labs(dividend);
        long long divis=labs(divisor);
        int result=0;
            while (divid >= divis) { 
            long long temp = divis, mul = 1;
            while (divid >= (temp << 1)) {
                temp <<= 1;
                mul<<= 1;
            }
            divid -= temp;
            result += mul;
        }
        return sign == 1 ? result : -result; 
    }

};

33. Search in Rotated Sorted Array

Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
(i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).
You are given a target value to search. If found in the array return its index, otherwise return -1.
You may assume no duplicate exists in the array.
Subscribe to see which companies asked this question.

目标：在数组中查找目标元素，但数组的排序可能是截断的。

最简单的方法是sort数组后在查找。更高效率的是用一个改版的二分查找。
1.找到数组中的最大值，该值将数组分为两半。
2.根据target的值决定在那一半使用二分查找。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        if(nums.size()==0)
            return -1;
        if(nums.size()==1)
            return nums[0]==target?0:-1;
        if(nums.size()==2)
        {
            if(target==nums[0])
                return 0;
            else if(target==nums[1])
                return 1;

            return -1;
        }
        else
        {
        int low=0;
        int high=nums.size()-1;
        while(low<high)
        {
            if(low+1==high)
            {
                if(nums[low]>nums[high])
                    break;
                else
                {
                    low=high;
                    break;
                }
            }
            int mid=(low+high)/2;
            if(nums[low]<nums[mid])
                low=mid;
            else if(nums[low]>nums[mid])
                high=mid-1;
            else if(nums[low]<nums[high])
            {
                low=high;
                break;
            }
        }

        int maxone=low;

        if(target>=nums[0])
        {
            low=0;
            high=maxone;
            while(low<=high)
            {
                int mid=(low+high)/2;
                if(target==nums[mid])
                    return mid;
                else if(target>nums[mid])
                    low=mid+1;
                else if(target<nums[mid])
                    high=mid-1;
            }
            return -1;
        }
        else 
        {
            low=maxone+1;
            high=nums.size()-1;
             while(low<=high)
            {
                int mid=(low+high)/2;
                if(target==nums[mid])
                    return mid;
                else if(target>nums[mid])
                    low=mid+1;
                else if(target<nums[mid])
                    high=mid-1;
            }
            return -1;
        }
        }
    }
};