剑指offer-和为S的两个数组-两根指针

问题

题目：[和为S的两个数组]

思路

这个题目解法很多了，这个办法是最好的。我之前用哈希表也做过。不过他是用两根指针做了。

代码

class Solution {
public:
    vector<int> FindNumbersWithSum(vector<int> array,int sum) {
        vector<int> ret;
        int sz = array.size();
        if(!sz) return ret;

        int i = 0;
        int j = sz - 1;
        while(i != j){
            int tmp = array[i] + array[j];
            if(tmp == sum) break;
            else if(tmp < sum) ++i;
            else --j;
        }


        if(i==j) return ret;
        ret.push_back( array[i] );
        ret.push_back( array[j] );
        return ret;
    }
};

思路

毕竟有序数组，折半查找了。$O(N * log_{N})$
哈希也是常用思路，应该考虑到了。

代码

class Solution {
public:
    vector<int> FindNumbersWithSum(vector<int> array,int sum) {
        int sz = array.size();
        vector<int> ret;
        vector<vector<int>> tmp_arr;

        if(!sz) return ret;
        for(int i = 0; i < sz; ++i){
            int key = sum - array[i];
            int pos = bi_search( array, 0, sz - 1, key );
            if( pos != -1 && pos != i ){
                vector<int> tmp;
                tmp.push_back( array[i] );
                tmp.push_back( array[pos] );
                tmp_arr.push_back( tmp );
            }
        }

        int ans_idx = -1;
        int min = INT_MAX;
        for(int i = 0; i < tmp_arr.size(); ++i){
            if( tmp_arr[i][0] * tmp_arr[i][1] < min ){
                min = tmp_arr[i][0] * tmp_arr[i][1];
                ans_idx = i;
            }
        }
        if( -1 == ans_idx ) return vector<int>();
        return tmp_arr[ans_idx];
    }
private:
    int bi_search( vector<int>& arr, int low, int high, int key ){
        if( low > high ) return -1;

        while(low <= high){
            int mid = (low+high)/2;
            if( arr[mid] == key ) return mid;
            else if( key < arr[mid] ) high = mid - 1;
            else low = mid + 1;
        }
        return -1;
    }
};