Two Sum

 

Given an arrayof integers, find two numbers such that they add up to a specific targetnumber.

The functiontwoSum should return indices of the two numbers such that they add up to thetarget, where index1 must be less than index2. Please note that your returnedanswers (both index1 and index2) are not zero-based.

You may assumethat each input would have exactly one solution.

Input: numbers={2, 7, 11, 15}, target=9

Output: index1=1, index2=2

class Solution {
public:
    void keepSort(vector<int> &array,vector<int>&src,int pos,int size ){
        int n = size;
        int left = 2*pos+1;
        int right = 2*pos+2;
        int min = pos;
        if ( pos<=n/2 ){
            if (  left <n && src[array[min]] < src[array[left]]  ){
                min = left;
            }
            if ( right<n && src[array[min]] < src[array[right]] ){
                min = right;
            }
            
            if ( min!=pos ){
                swap(array[min],array[pos]);
                keepSort(array,src,min,size);
            }   
        }
    }
    void buildHeap(vector<int> &array,vector<int> &src){
        int size = array.size();
        for ( int i=size/2; i>=0; --i ){
            keepSort(array,src,i,size);
        }
    }
    void heapSort(vector<int> &numbers,vector<int> &src){
        buildHeap(numbers,src);
        
        int size = numbers.size();
        while ( --size ){
            swap(numbers[0],numbers[size]);
            keepSort(numbers,src,0,size);
        }
    }
    vector<int> twoSum(vector<int> &numbers, int target) {
        vector<int> array;
        vector<int> pos;
        int n = numbers.size();
        for ( int i=0; i<n ; ++i ){
            pos.push_back(i);
        }
        heapSort(pos,numbers);
        int i=0,j=numbers.size()-1;
        while ( i<j ){
            if ( numbers[pos[i]]+numbers[pos[j]]==target ){
                if (pos[i]>pos[j]){
                    swap(pos[i],pos[j]);
                }
                array.push_back(pos[i]+1);
                array.push_back(pos[j]+1);
                break;
            } else if(numbers[pos[i]]+numbers[pos[j]]<target) {
                ++i;   
            } else{
                --j;
            } 
        }
        return array;
    }

};