leetcode:Two Sum

 struct Node
    {
      int val;
      int index;
      Node(){}
      Node(int x,int y):val(x),index(y){}
    };
    
    bool compare(const Node &aa, const Node &bb)
    {
        return aa.val<bb.val;
    }
class Solution {
public:
   
    vector<int> twoSum(vector<int> &numbers, int target) 
    {
        int i,j;
     
        vector<struct Node> node;
        int len = numbers.size();
        for(i=0;i<len;i++)
        {
            node.push_back(Node(numbers[i],i+1));
        }
        sort(node.begin(), node.end(), compare);
        vector<int> result;
        for(i=0,j=len-1;i<j;)
        {
            if(node[i].val+node[j].val>target)
                j--;
            if(node[i].val+node[j].val<target)
                i++;
            if(node[i].val+node[j].val==target)
            {
                if(node[i].index<node[j].index)
                {
                result.push_back(node[i].index);
                result.push_back(node[j].index);
                }
               else
               {
                   result.push_back(node[j].index);
                   result.push_back(node[i].index);
               }
              
                return result;
            }
        }
    }
};

第二次：

class Solution {
public:
    struct Node
    {
        int val;
        int index;
        Node(int i = 0, int j = 0):val(i),index(j){};
        bool operator < (const Node &other) const
        {
            return val<other.val;
        }
    };
    vector<int> twoSum(vector<int> &numbers, int target)
    {
            int len = numbers.size();
            int i,j;
            vector<int>re;
            vector<Node>no(len);
            for(i=0;i<len;++i)
            {
                no[i].val = numbers[i];
                no[i].index = i+1;
            }
            sort(no.begin(),no.end());
            i=0;
            j=len-1;
            while(i<j)
            {
                if(no[i].val+no[j].val==target)
                {
                    re.push_back(min(no[i].index,no[j].index));
                    re.push_back(max(no[i].index,no[j].index));
                    break;
                }
                else if(no[i].val+no[j].val>target)
                    j--;
                else
                    i++;
            }
            return re;
    }
};

还有一个简单的方法，思路如下 ：

1. 用hash表是否可解决，hash表的存的是target-numbers[i]的值，第一遍，hash[numbrs[i]] = target - numbers[i];

2. 第二次扫描的时候，对于numbers[i], 直接看hash[target-numbers[i]]是否有值，如果不为0，则找到了，再搜后面的，就可以找到一对

但这里有条件，因为，numbers的值范围不确定，可能还有负数。如果范围小，则可以使用这个方法 

主要思想是排序后，一次就可以搜索出来