two sum

Given an array of integers, find two numbers such that they add up to a specific target number.The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based.

You may assume that each input would have exactly one solution.

Input: numbers={2, 7, 11, 15}, target=9
Output: index1=1, index2=2

*******************************************************************************************************

Anwer 1: O(n^2)

class Solution {
public:
 
    vector<int> twoSum(vector<int> &numbers, int target) {
        int len = numbers.size();
        vector<int> results;

        for(int i = 0; i < len - 1; i++) {
            for(int j = i + 1; j < len; j++){
                int sum = numbers[i] + numbers[j];
                if(sum == target) {
                    results.push_back(i + 1);
                    results.push_back(j + 1);
                    
                    return results;
                }
            }
        }

  }
};

Anwer 2: O(n*log(n)

class Solution {
public:

    struct node {
        /*bool operator > (const node& a) const {
            return val > a.val;
        }*/
        bool operator < (const node& a) const {
            return val <= a.val;
        }
        int idx; // record itself
        int val;
    };
    
    // must use static to decorate
    static bool cmp(const node *a, const node *b);
    
    /*
        since a, b in numbers, so if a + b == target,
        so b = target - a
        means that (target - a) must in numbers
        so just iterately check target - numbers[i] is in numbers or not
        here you can binary_search after sort the the copy of the numbers
    */
    vector<int> twoSum(vector<int> &numbers, int target) { 
        // check
        assert(numbers.size() >= 2);
        
        vector<int> results;
        vector<node> num;
        
        int len = numbers.size();
        for(int i = 0; i < len; i++) {
            node temp;
            temp.idx = i;
            temp.val = numbers[i];
            num.push_back(temp);
        }
        
        // ascending order -- use overload operator <
        // also you can use cmp static function
        sort(num.begin(), num.end());
        
        int slen = num.size();
        for(int i = 0; i < slen; i++) {
            int dval = target - num[i].val;
            
            int index = binary_search(num, dval, 0, slen - 1);
            
            if(index != -1) {
                int left = num[i].idx;
                int right = num[index].idx;
                
                if(left == right) {
                    continue;
                }
                
                if(left > right) {
                    swap(left, right);
                }
                
                // index: start from 1
                results.push_back(left + 1);
                results.push_back(right + 1);
                
                break;
            }
        }
        
        return results;
    }
    
    int binary_search(vector<node> &A, int target, int left, int right) {
        while(left < right) {
            int mid = (left + right) >> 1;
            
            if(A[mid].val == target) {
                return mid;
            } else if(A[mid].val < target) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        
        return -1;
    }
};


bool Solution::cmp(const node *a, const node *b) {
    return a->val < b->val;
}

Anwer 3: O(n*log(n))

class Solution {
public:

    struct node {
        /*bool operator > (const node& a) const {
            return val > a.val;
        }*/
        bool operator < (const node& a) const {
            return val <= a.val;
        }
        int idx; // record itself
        int val;
    };
    
    // must use static to decorate
    static bool cmp(const node *a, const node *b);
    
    /*
        since a, b in numbers, so if a + b == target,
        so b = target - a
        means that (target - a) must in numbers
        so just iterately check target - numbers[i] is in numbers or not
        here you can  after sort the the copy of the numbers
    */
    vector<int> twoSum(vector<int> &numbers, int target) { 
        // check
        assert(numbers.size() >= 2);
        
        vector<int> results;
        vector<node> num;
        
        int len = numbers.size();
        for(int i = 0; i < len; i++) {
            node temp;
            temp.idx = i;
            temp.val = numbers[i];
            num.push_back(temp);
        }
        
        // ascending order -- use overload operator <
        // also you can use cmp static function
        sort(num.begin(), num.end());
        
        int slen = num.size();
        
        int left = 0;
        int right = slen - 1;
        while(left < right) {
            int sum = num[left].val + num[right].val;
            if(sum == target) {
                int lidx = min(num[left].idx, num[right].idx) + 1;
                int ridx = max(num[left].idx, num[right].idx) + 1;
                
                results.push_back(lidx);
                results.push_back(ridx);
                
                break;
            } else if(sum < target) {
                left++;
            } else {
                right--;
            }
        }
        
        return results;
    }

};


bool Solution::cmp(const node *a, const node *b) {
    return a->val < b->val;
}

Anwer 4: O(n)

class Solution {
public:

    
    /*
        since a, b in numbers, so if a + b == target,
        so b = target - a
        means that (target - a) must in numbers
        so just iterately check target - numbers[i] is in numbers or not
        here you can  use map or pair
    */
    vector<int> twoSum(vector<int> &numbers, int target) { 
        // check
        assert(numbers.size() >= 2);
        
        vector<int> results;
        map<int, int> num;
        
        int len = numbers.size();
        for(int i = 0; i < len; i++) {
            int diff = target - numbers[i];
            
            // fist determine numbers[i] is visited or not
            // and then insert it to map
            if(num.find(numbers[i]) == num.end()){
                num[numbers[i]] = i;
            }
            
            // second determine the diff (another numbers[j]) is in num or not
            if(num.find(diff) != num.end()) {
                int j = num[diff];
                
                // some cases like this: numbers[i] + numbers[i] == target
                if(i == j){
                    continue;
                }
                
                if(i > j) {
                    swap(i, j);
                    
                    // result's index: start from 1
                    results.push_back(i + 1);
                    results.push_back(j + 1);
                    break;
                }
            }
        }
        
        return results;
    }

};