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

思路：首先可能想到的是两层循环，第一层是记录首个index，第二层是记录第二个index，时间复杂度O(N^2)，超时。然后考虑到可以给numbers排序，排序的算法时间复杂度必须小于O(N^2)，本次选用快速排序。然后利用两个指针，一个指向数组头，一个指向数组尾部，如果两者之和大于target，尾部指针向左推进一步；如果两者之和小于target，头部指针向右推进一步；若相等则退出。时间复杂度为O(N) + O(NlogN)=O(NlogN)

class Solution {
private:
    struct Data
    {
        int val;
        int index;
        Data(int a, int b): val(a), index(b){}
    };    
public:
    int Partion(vector<int> &numbers, int left, int right, vector<int> &position)
    {
        int partion = numbers[(left + right) / 2];
        while(left <= right)
        {
            while(numbers[left] < partion)
             left++;
            while(numbers[right] > partion)
             right--;
            if (left <= right)
            {
                int tmp = numbers[left];
                numbers[left] = numbers[right];
                numbers[right] = tmp;
                tmp = position[left];
                position[left] = position[right];
                position[right] = tmp;
                left++;
                right--;
            }    
        }  
        return left; 
    }    
    void quickSort(vector<int> &numbers, int left, int right, vector<int> &position)
    {
        int index = Partion(numbers, left, right, position);
        if (left < index - 1) //排序左边
          quickSort(numbers, left, index - 1, position); 
        if (index < right)  //排序右边 
          quickSort(numbers, index, right, position); 
    }   
    vector<int> twoSum(vector<int> &numbers, int target) {
        vector<int> result;
        vector<int> sortNums;
        vector<int> position;
        int len = numbers.size();
        int L = 0, R = len - 1, M;
        int i;
        for(i=0; i<len; i++)
        {
            sortNums.push_back(numbers[i]);
            position.push_back(i+1);
        } 
        quickSort(sortNums, 0, len-1, position);   
        while(L < R)
        {
            if (sortNums[L] + sortNums[R] == target)
            {
                if (position[L] < position[R])
                {
                    result.push_back(position[L]);
                    result.push_back(position[R]);
                }    
                else
                {
                    result.push_back(position[R]);
                    result.push_back(position[L]);
                }   
                break;
            }    
            else if(sortNums[L] + sortNums[R] < target)
            {
                L++;
            }  
            else
            {
                R--;
            }      
        }   
        return result;    
    }
};