leetcode初级算法——两数之和

问题描述：

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

链接：https://leetcode.cn/leetbook/read/top-interview-questions-easy/x2jrse/
来源：力扣（LeetCode）

解法一：差值数组与原数组求重法

   思路：先求原数组与target的差数组，再对差值数组和原数组快速排序，再求两个数组交集元素在原数组中的下标

 int quickSort(int* arr, int low, int high){

    int piv = arr[low];//任取枢轴值

    while(low < high){ //low = high 时，确定枢轴坐标，结束循环

        while(low < high && arr[high] >= piv) high--;//从右取一个小于枢轴值的元素a

        arr[low] = arr[high];//a左置

        while(low < high && arr[low] <= piv) low++;//从左取一个大于枢轴值的元素b

        arr[high] = arr[low];//b右置

    }

    arr[low] = piv; //枢轴归位

    return low; //返回枢轴坐标

}

void sort(int* arr, int low, int high){

    if(low < high){ //递归结束条件

        int piv = quickSort(arr, low, high); //拿到枢轴坐标

        sort(arr, low, piv - 1); //左数组排序

        sort(arr, piv + 1, high); //右数组排序

    }

}

int* twoSum(int* nums, int numsSize, int target, int* returnSize){

    if(!nums || numsSize < 2) return NULL; //特殊情况判断

    int arr[numsSize], copyArr[numsSize], i;

    //计算差值数组

    for(i = 0; i < numsSize; i++){

        arr[i] = target - nums[i];

    }

    //拷贝原数组,便于查找加数坐标

    for(i = 0; i < numsSize; i++){

        copyArr[i] = nums[i];

    }

    //快速排序

    sort(arr, 0, numsSize - 1);

    sort(nums, 0, numsSize - 1);

    //双指针求数组交集

    int p = 0, q = 0;

    while(p < numsSize && q < numsSize){

        if(nums[p] == arr[q]) break;

        else if(nums[p] > arr[q]) q++;

        else p++;

    }

    //获取加数

    int plus1 = nums[p];

    int plus2 = target - plus1;

    //查找加数坐标

    int* finArr = (int*)malloc(sizeof(int) * 2), count = 0;//count记录已查找到的元素个数

    finArr[0] = -1;

    finArr[1] = -1;

    for(i = 0; i < numsSize; i++){

        if(copyArr[i] == plus1 && finArr[0] == -1){

            finArr[0] = i;

            count++;

        }else if(copyArr[i] == plus2 && finArr[1] == -1){

            finArr[1] = i;

            count ++;

        }

        if(count == 2) break;

    }

    *returnSize = 2;

    return finArr;

}

解法二：双重for循环暴力求解

int* twoSum(int* nums, int numsSize, int target, int* returnSize){

    if(!nums || numsSize < 2) return NULL; //特殊情况判断

    int i, j;

    int* arr = (int*)malloc(sizeof(int) * 2);

    for(i = 0; i < numsSize - 1; i++){

        for(j = i + 1; j < numsSize; j++){

            if(nums[i] + nums[j] == target){

                arr[0] = i;

                arr[1] = j;

                *returnSize = 2;

                return arr;

            }

        }

    }

    return NULL;

}

————————————————————————————————————

  其实一看到这个题就想到的是暴力解法，但是不甘心，想求一个性能更好的解法。做了好几个小时终于写出来一个不同的解法，谁知性能甚至不如暴力解法...

  求大佬指点。