C语言geetcode算法常见题集（四）

十、（167题）两数之和

给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列  ，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。

以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。

你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。

你所设计的解决方案必须只使用常量级的额外空间。

 
示例 1：

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。
示例 2：

输入：numbers = [2,3,4], target = 6
输出：[1,3]
解释：2 与 4 之和等于目标数 6 。因此 index1 = 1, index2 = 3 。返回 [1, 3] 。
示例 3：

输入：numbers = [-1,0], target = -1
输出：[1,2]
解释：-1 与 0 之和等于目标数 -1 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。
 

提示：

2 <= numbers.length <= 3 * 104
-1000 <= numbers[i] <= 1000
numbers 按 非递减顺序 排列
-1000 <= target <= 1000
仅存在一个有效答案

代码实现：

法一（暴力枚举法）：空间复杂度O（1），时间复杂度为O（n²），此法LeetCode上面跑不过去。：

int* twoSum(int* numbers, int numbersSize, int target, int* returnSize){
	int i = 0, j = 0;
	int* re = (int*)malloc(sizeof(long)* 2);//开辟内存空间
	(*returnSize) = 2;
	for (i = 0; i<numbersSize; i++){//外部循环控件
		for (j = 1; j<numbersSize - i; j++){//内部循环控件
		if (target == (numbers[i] + numbers[i + j])){//如果target等于numbers中的两个数的和
				if (i == (i + j)){//避免重复使用该数
					break;
				}
				else{
					re[0] = i + 1;
					re[1] = i + j + 1;
					return re;//返回数组下标
				}

			}
		}
	}
	return re;
}

法二（双指针法）空间复杂度O（1），时间复杂度为O（log（n）：

int* twoSum(int* numbers, int numbersSize, int target, int* returnSize){
	int left = 0, right = numbersSize - 1;//左右控件
	int* re = (int*)malloc(sizeof(long)* 2);//开辟内存空间
	(*returnSize) = 2;
	while (left<right){//如果左下标大于右下标循环终止
		if (target == (numbers[left] + numbers[right])){//如果找到两个数之和等于目标值返回数组下标
			re[0] = left + 1;
			re[1] = right + 1;
			return re;
		}
		else if (target>(numbers[left] + numbers[right])){//如果目标值大于两数之和，目标值区间[left+1,right]
			left++;
		}
		else{//如果目标值小于两数之和，目标值区间[left,right-1]
			right--;
		}
	}
	return re;
}

执行结果：

十一、有序数组的平方：

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]
 

提示：

1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 已按 非递减顺序 排序

代码实现：

int* sortedSquares(int* nums, int numsSize, int* returnSize){
    int i= 0,j =0,temp = 0;
    int* re = (int*) malloc(sizeof(int)*(numsSize));//开辟内存空间
    (*returnSize) = numsSize;
    //赋值
    for(i = 0;i<=numsSize-1;i++){
        re[i]=nums[i]*nums[i];
    }
    //排序
    for(i = 0 ;i<=numsSize - 1;i++){
        for(j = 1;j<=numsSize-1-i;j++){//j=1避免非法访问
            if(re[j-1]>re[j]){
               temp =  re[j-1];
               re[j-1] = re[j];
               re[j]=temp;
            }
        }
    }
    return re;
}

 输出结果：

十二、（278题）第一个错误版本

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。

假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。

你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

 
示例 1：

输入：n = 5, bad = 4
输出：4
解释：
调用 isBadVersion(3) -> false 
调用 isBadVersion(5) -> true 
调用 isBadVersion(4) -> true
所以，4 是第一个错误的版本。
示例 2：

输入：n = 1, bad = 1
输出：1

代码实现：

//二分法
int firstBadVersion(int n) {
    int left = 0,right = n,mid = 0;
    while(left<right){ 
        mid =left + (right-left)/2;
        if(isBadVersion(mid)){
            right = mid;
        }else{
            left = mid + 1;
        }
    }
    return right;
}

结果如下：

 以上仅题目均来源于力扣，解题思路仅代表个人想法，如有不对之处请批评指正！！

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/two-sum-ii-input-array-is-sorted
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。