LeetCode 1 Two Sum

题目

分析

看完题目首先可以考虑直接暴力破解，不过O(n*2)的时间复杂度会超时，需要降低时间复杂度。

1.先进行一个快排，两个指针分别指向首(i)尾(j)，若和大于要求值则 j--，否则i++

2.先进行一个快排，再在数组中通过二分查找另一个数。

题解

1.

void swap(int *x, int *y)
{
    int temp;
    temp = *x;
    *x = *y;
    *y = temp;
    return;

}

void sort(int arr[],int ind[],int left,int right)
{
    if(left>right)
        return;
    int i=left;
    int j=right;
    int mid=(left+right)/2;
    swap(&arr[mid],&arr[left]);
    swap(&ind[mid],&ind[left]);
    int temp=arr[left];
    while(i!=j)
    {
        while(arr[j]>=temp && i<j)
            j--;
        while(arr[i]<=temp && i<j)
            i++;
            
        if(i<j)
        {
            swap(&arr[i],&arr[j]);
            swap(&ind[i],&ind[j]);
        }
    }
    swap(&arr[i],&arr[left]);
    swap(&ind[i],&ind[left]);
    
    sort(arr,ind,left,i-1);
    sort(arr,ind,i+1,right);
    
}

另外一个数组是为了在交换的时候将下标号也跟着交换。

int *twoSum(int numbers[], int n, int target) {
    int *a=(int *)malloc(2*sizeof(int));
    int *index=(int *)malloc(n*sizeof(int));
    for(int i=0;i<n;i++)
        index[i]=i+1;
    a[0]=a[1]=-1;
    sort(numbers,index,0,n-1);
    int i=0;
    int j=n-1;
    while (i!=j) {
        if(numbers[i]+numbers[j]==target)
        {
            if(index[i]>index[j])
            {
                a[0]=index[j];
                a[1]=index[i];
            }
            else
            {
                a[0]=index[i];
                a[1]=index[j];
            }
            break;
        }
        else if(numbers[i]+numbers[j]<target)
            i++;
        else
            j--;
    }
    return a;
}

2.

int search(int arr[],int value,int left,int right)
{
    if(left>right)
        return -1;
    int mid=(left+right)/2;
    if(arr[mid]==value)
        return mid;
    else if (arr[mid]>value)
        return search(arr,value,left,mid-1);
    else
        return search(arr,value,mid+1,right);
    
}

swap函数和sort函数同解1.

int *twoSum(int numbers[], int n, int target) {
    int *a=(int *)malloc(2*sizeof(int));
    int *index=(int *)malloc(n*sizeof(int));
    for(int i=0;i<n;i++)
        index[i]=i+1;
    a[0]=a[1]=-1;
    sort(numbers,index,0,n-1);
    for(int i=0;i<n;i++) 
    {
        int j=search(numbers,target-numbers[i],i+1,n-1);
        if(j!=-1)
        {
            if(index[i]>index[j])
            {
                a[0]=index[j];
                a[1]=index[i];
            }
            else
            {
                a[0]=index[i];
                a[1]=index[j];
            }
            break;
        }
    }
    return a;
}

再说说快排

 int mid=(left+right)/2;
 swap(&arr[mid],&arr[left]);
 swap(&ind[mid],&ind[left]);

快排里面有这神奇的三句，是因为再没加之前是超时的，错误的例子是一个递增的长序列。

在这个递增的长序列中，不论是以最左边为参照还是以最右边为参照都会全部进行比较，时间复杂度为O(N*2)

这样还是过不去的（如果这样都能过，不如直接写两层for循环）

于是投机的把最中间的值先换到了左边，再也左边为参照，一次全部交换完毕才通过了测试。

不仅能写出算法，还     知道它最适合的情景和最不适合的情景    也是很重要的。

再试试桶排序

int *twoSum(int numbers[], int n, int target) {
    int *a=(int *)malloc(2*sizeof(int));
    int *index=(int *)malloc(40000*sizeof(int)); //定义40000个桶 默认值为-1
    for(int i=0;i<40000;i++)
        index[i]=-1;
    for(int i=0;i<n;i++)                 //将元素的索引存在 值+1000 的地桶里
    {
        index[numbers[i]+1000]=i;
    }
    int temp,j;
    for(int j=0;j<n;j++)
    {
        temp=index[target-numbers[j]+1000];     // 查找另一个数时，查找该数值+1000的桶里有没有不为-1的排号
        if(temp!=-1 && temp!=j)                 // 不为-1的排号 且与第一个数索引不同 则为另一个值的索引
        {
            if(j>temp)
            {
                a[0]=temp+1;
                a[1]=j+1;
            }
            else
            {
                a[0]=j+1;
                a[1]=temp+1;
            }
            return a;
        }
    }
    
}

加1000是为了使得下标值都为正数

试试C++

class Solution {
public:
    vector<int> twoSum(vector<int> &numbers, int target) {
        vector<int> results;
        multimap<int, int> iimmap;
        for(int i=0; i<numbers.size(); i++){
            iimmap.insert(pair<int, int>(numbers[i], i));
        }
        for(int i=0;i<numbers.size();i++)
        {
            if(iimmap.count(target-numbers[i]))
            {
                int n=iimmap.find(target-numbers[i])->second;
                if(n<i)
                 {
                    results.push_back(n+1);
                    results.push_back(i+1);
                    return results;
                 }
                 else if(n>i)
                 {
                    results.push_back(i+1);
                    results.push_back(n+1);
                    return results;
                 }
                
            }
        }
    }
};

思路同桶排序一样，不过更简单，不用考虑数组下标为负时需要做的偏移。用到了：

1.multimap的插入，直接插入pair<int,int>类型的数据

2.通过multimap.count(key)来统计是否有key主键存入

3.multimap.find(key)得到指向key的iterator  iterator->second获得了key对应的value值，也就是我们需要的索引值。

简单点

class Solution {
public:
    vector<int> twoSum(vector<int> &numbers, int target) {
        map<int, int> iimmap;
        vector<int> results;
        for(int i=0; i<numbers.size(); i++){
            if(iimmap.count(target-numbers[i])){
                int n=iimmap.find(target-numbers[i])->second;
                    results.push_back(n+1);
                    results.push_back(i+1);
                    return results;
            }
            iimmap.insert(pair<int, int>(numbers[i], i));
        }
        return results;
    }
};

用JAVA的Hashmap

public class Solution {
   public int[] twoSum(int[] numbers, int target) {
   Map<Integer, Integer> map = new HashMap<>();
   for (int i = 0; i < numbers.length; i++) {
      if (map.containsKey(target - numbers[i])) {
         return new int[] { map.get(target - numbers[i]) + 1, i + 1 };
      }
      map.put(numbers[i], i);
   }
   throw new IllegalArgumentException("No two sum solution");
 }
}

其实上面的两次for循环只是为了看起来理解更方便，实际上一次for循环就能解决。