一. 简介
本文记录一下力扣网上涉及数组的问题：在旋转排序数组中查找目标值。这里主要练习使用双指针或者使用二分查找法解决。
二. 力扣网C语言编程题：寻找两个正序数组的中位数
题目：寻找两个正序数组的中位数
给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
算法的时间复杂度应该为 O(log (m+n)) 。
示例 1：
输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2
示例 2：
输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5
提示：
nums1.length == m
nums2.length == n
0 <= m <= 1000
0 <= n <= 1000
1 <= m + n <= 2000
-106 <= nums1[i], nums2[i] <= 106
解题思路一：（从前往后 / 双指针，排序合并）
1. 首先，申请一段内存，拷贝数组nums1所有元素；
2. 然后，准备三个指针，从前往后，合并排序（从小到大）； 处理剩余元素；
3. 最后，计算中位数；
C语言实现如下：
//寻找两个正序数组的中位数
double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size) {
int* nums = (int*)malloc((nums1Size+nums2Size)*sizeof(int));
int p = 0; //指向拼接后的数组元素
int p1 = 0;//指向数组nums1的元素
int p2 = 0;//指向数组nums2的元素
memcpy(nums, nums1, nums1Size*sizeof(int));
//从前往后合并（从小到大）
while(p1 < nums1Size && p2 < nums2Size) {
//比较大小，最大值存入
if(nums1[p1] <= nums2[p2]) {
nums[p] = nums1[p1];
p1++;
}
else { //nums1[p1]>nums2[p2]
nums[p] = nums2[p2];
p2++;
}
p++;
}
//处理剩余的元素
//可能一个数组nums1的元素已排序完，还剩下nums2的元素的情况
while(p1 < nums1Size) {
nums[p] = nums1[p1];
p1++;
p++;
}
while(p2 < nums2Size){
nums[p] = nums2[p2];
p2++;
p++;
}
double median = 0;
if(p % 2 == 0) {
median = (nums[p/2]+ nums[p/2-1]) / 2.0;
}
else {
median = nums[p/2];
}
return median;
}可以看出，这种解法的时间复杂度为 O(m+n)，空间复杂度为 O(m+n)。但是，这种解法不符合题目要求的时间复杂度。
解题思路二：（二分查找法）
二分查找法的时间复杂度为O(log (m+n)) ，所以，其实这里题目要求的二分查找法来解决。
查找两个有序数组合并后中位数可以转换为寻找两个数组中第 k 小的元素。
对于有序数组nums1和 nums2，假设两个数组元素个数分别为 m，n。
中位数与第k小元素的关系：
中位数本质上是求第 k小元素的特例：
当两个数组长度和m+n为奇数时，中位数 = 第 (m+n)/2+1小的元素（从1开始）；
当两个数组长度和m+n为偶数时，中位数 = 第 (m+n)/2 小的元素 + 第 (m+n)/2+1 小的元素] / 2.0；
算法核心思想
1. 问题分解：
每次比较两个数组第 [k/2]个元素：
若 nums1[k/2-1] < nums2[k/2-1]，说明 nums1 的前 k/2 个元素都不可能是第 k 小元素，可排除。
反之，排除 nums2 的前 k/2 个元素。
通过不断排除元素，将问题规模缩小为原来的一半。
2. 递归排除：
nums1[i-1] > nums2[j-1] → 排除nums2的前j个元素
nums1[i-1] <= nums2[j-1] → 排除nums1的前i个元素3. 边界处理：
当某个数组为空时，直接返回另一个数组的第 k 小元素。
当 k=1 时，返回两数组当前首元素的最小值。
C语言实现如下：
//二分查找法
int find_kth_smallest(int* nums1, int m, int* nums2, int n, int k) {
//保证数组nums1是最短数组，减少递归次数
if(m > n) {
return find_kth_smallest(nums2, n, nums1, m, k);
}
//处理边界
//1. 数组nums1为空，nums2不为空的情况
//返回数组中第 k小的元素
if(m == 0){
return nums2[k-1];
}
//2. k=1的情况
if(k == 1){
return (nums1[0] < nums2[0])? nums1[0]: nums2[0];
}
//计算分割点：比较两个数组的第k小的元素
int i = ((k / 2) > m) ? m : k/2; // nums1的分割点，防止越界
int j = ((k / 2) > n) ? n : k/2; // nums2的分割点，防止越界
//比较nums1[k/2]和nums2[k/2]大小，排除较小的数组的第k/2小的元素
if(nums1[i-1] < nums2[j-1]) {
//排除数组nums1中前i个元素，在剩余元素中继续查找第 k-i小的元素
return find_kth_smallest(nums1+i, m-i, nums2, n, k-i);
}
else{ //nums1[i] >= nums2[j]
//排除数组nums2中前j个元素，在剩余元素中继续查找第 k-j小的元素
return find_kth_smallest(nums1, m, nums2+j, n-j, k-j);
}
}
double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size) {
int elements_cnt = nums1Size+nums2Size;
double median;
if(elements_cnt % 2 != 0) { //奇数个元素
median = find_kth_smallest(nums1, nums1Size, nums2, nums2Size, elements_cnt/2+1);
}
else{ //偶数个元素
int element1 = find_kth_smallest(nums1, nums1Size, nums2, nums2Size, elements_cnt/2);
int element2 = find_kth_smallest(nums1, nums1Size, nums2, nums2Size, elements_cnt/2+1);
median = (element1+element2) / 2.0;
}
return median;
}这个解法满足题目要求了，算法的时间复杂度为 O(log(m+n))。