Median of Two Sorted Arrays

accepted，思路太繁琐，不够优美，就不写了。
可以直接查看系统的提示方案去做；

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int size1 = nums1.size();
        int size2 = nums2.size();
        int right1 = size1 - 1;
        int right2 = size2 - 1;
        int left1 = 0, left2 = 0;
        double result;
        vector<int> re2;

        int total1 = size1 - 1;
        int total2 = size2 - 1;
        int cutNum = 0;
        double median1, median2, m1inN2, m2inN1, medPos1, medPos2;

        if(size1>0 && size2>0)
        do {
            total2 = (right2 + left2);
            total1 = (right1 + left1);

            size1 = right1 - left1 + 1;
            size2 = right2 - left2 + 1;

            cutNum = (size1>size2) ? size2 / 2 : size1 / 2;


            medPos1 = total1 / 2.0;
            medPos2 = total2 / 2.0;
            median1 = ((total1) % 2) ? (nums1[total1 / 2] + nums1[total1 / 2 + 1]) / 2.0 : nums1[total1 / 2];
            median2 = (total2 % 2) ? (nums2[total2 / 2] + nums2[total2 / 2 + 1]) / 2.0 : nums2[total2 / 2];

            if ((((total1) % 2 && (median2 > nums1[total1 / 2] && median2 < nums1[total1 / 2 + 1]) )  )&& size1>1 && size2>1) {

                    //cout<<endl << nums1[total1 / 2] << "a:" << nums1[total1 / 2 + 1]; cout << endl << nums2[total2 / 2] << "a1:" << nums2[total2 / 2 + 1];  
                if(total2%2 == 0) return median2;
                else{
                    re2.push_back(nums1[total1 / 2]);
                    re2.push_back(nums1[total1 / 2 + 1]);
                    re2.push_back(nums2[total2 / 2]);
                    re2.push_back(nums2[total2 / 2 + 1]);
                    sort(re2.begin(), re2.end());

                    return (re2[1] + re2[2]) / 2.0;
                }

            }

            if((((total2 % 2) && (median1 > nums2[total2 / 2] && median1 < nums2[total2 / 2 + 1])) )&& size1>1 && size2>1){

                if(total1%2 == 0) return median1;
                else{
                    re2.push_back(nums1[total1 / 2]);
                    re2.push_back(nums1[total1 / 2 + 1]);
                    re2.push_back(nums2[total2 / 2]);
                    re2.push_back(nums2[total2 / 2 + 1]);
                    sort(re2.begin(), re2.end());

                    return (re2[1] + re2[2]) / 2.0;
                }
            }

            right1 = median1 > median2 ? right1 - cutNum : right1;
            right2 = median1 > median2 ? right2 : right2 - cutNum;
            left1 = median1 > median2 ? left1 : left1 + cutNum;
            left2 = median1 > median2 ? left2 + cutNum : left2;
        } while (size1 > 1 && size2 > 1 );

        size1 = right1 - left1 + 1;
        size2 = right2 - left2 + 1;
        total2 = (right2 + left2);
        total1 = (right1 + left1);
        if (size1 <= 0 || size2 <= 0) {
            if (size1 <= 0) {
                //cout<<endl << nums2[total2 / 2] << "c:" << nums2[total2 / 2 + 1];
                return  (total2 % 2) ? (nums2[total2 / 2] + nums2[total2 / 2 + 1]) / 2.0 : nums2[total2 / 2];
            }
            else {
                //cout<<endl << nums1[total1 / 2] << "d:" << nums1[total1 / 2 + 1];
                return ((total1) % 2) ? (nums1[total1 / 2] + nums1[total1 / 2 + 1]) / 2.0 : nums1[total1 / 2];
            }
        }

        if (size1 == 2 && size2 == 2) {
            re2.push_back(nums1[left1]);
            re2.push_back(nums1[right1]);
            re2.push_back(nums2[left2]);
            re2.push_back(nums2[right2]);

            sort(re2.begin(), re2.end());
            //cout<<endl << re2[1] << "e:" << re2[2];
            return (re2[1] + re2[2]) / 2.0;
        }

        m1inN2 = binarySearchPos(nums2, median1, left2, right2);
        m2inN1 = binarySearchPos(nums1, median2, left1, right1);

        if (size1>1) {

            if (m1inN2 < left2) {

                left1 += right1 - floor(m2inN1);
                right1 = floor(m2inN1);
            }
            else {
                right1 -= ceil(m2inN1) - left1;
                left1 = ceil(m2inN1);

            }

            size1 = right1 - left1 + 1;
            if (size1>1) {
                (m1inN2 < left2) && (left1 += 1);
                (m1inN2 > left2) && (right1 -= 1);
                total1 = (right1 + left1);
                //cout<<endl << nums1[total1 / 2] << "f:" << nums1[total1 / 2 + 1];
                result = ((total1) % 2) ? (nums1[total1 / 2] + nums1[total1 / 2 + 1]) / 2.0 : nums1[total1 / 2];
            }else if(size1==1){
                //cout<<endl << nums1[left1] << "g:" << nums2[left2];
                result = (nums1[left1] + nums2[left2]) / 2.0;
            }
            else {
                //cout<<endl << "k"<<nums2[left2];
                result = nums2[left2];
            }



        }
        else {
            if (m2inN1 < left1) {

                left2 += right2 - floor(m1inN2);
                right2 = floor(m1inN2);
            }
            else {
                right2 -= ceil(m1inN2) - left2;
                left2 = ceil(m1inN2);

            }
            size2 = right2 - left2 + 1;
            if (size2>1) {
                (m2inN1 < left1) && (left2 += 1);
                (m2inN1 > left1) && (right2 -= 1);
                total2 = (right2 + left2);
                cout << endl << nums2[total2 / 2] << "h:" << nums2[total2 / 2 + 1];
                result = ((total2) % 2) ? (nums2[total2 / 2] + nums2[total2 / 2 + 1]) / 2.0 : nums2[total2 / 2];
            }else if(size2 == 1){
                cout << endl << nums2[left2] <<"i:"<< nums1[left1];
                result = (nums2[left2] + nums1[left1]) / 2.0;
            }
            else {
                cout << endl <<"j"<< nums1[left1];
                result = nums1[left1];
            }

        }
        return result;

    }


    double binarySearchPos(vector<int>& nums1, double num, int start, int end) {
        int left = start, right = end, medium = 0;
        while (left<right) {
            medium = left + (right - left) / 2;
            if (nums1[medium] - num >0.4) {
                right = medium;
            }
            else if (num - nums1[medium] >0.4) {

                left = medium + 1;
            }
            else {
                return medium;
            }


        }
        double left1;
        if (nums1[left] - num<0.4 && num - nums1[left] <0.4)
            left1 = left;
        else if (nums1[left] - num>0.4) {
            left1 = left - 0.5;
        }
        else {
            left1 = left + 0.5;
        }
        return  left1;
    }
};