leetcode刷题——数组部分（排序、双指针、二分查找）

11. 盛最多水的容器（双指针）

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

思路：采用双指针法，从两侧开始，移动较短的指针到一个更高的地方（左指针向右移动，右指针向左移动）

int maxArea(int* height, int heightSize){
    int i = 0, j = heightSize - 1;
    int max = 0;
    while(i < j){
        int cur = (height[i] < height[j]) ? (height[i] * (j - i)) : (height[j] * (j - i));
        if(cur > max){
            max = cur;
        }
        if(height[i] < height[j]){  //i较短
            int h = height[i];
            while(i < j){
                if(height[i] > h){
                    break;
                }
                i++;
            }
        }else{
            int h = height[j];
            while(i < j){
                if(height[j] > h){
                    break;
                }
                j--;
            }
        }
    }
    return max;
}

15.三数之和（排序＋双指针）

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。

思路：

void swap(int* a, int* b){
    int temp = *a;
    *a = *b;
    *b = temp;
}

//排序+双指针
int** threeSum(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){
    int base = 100;  //设置一个初始大小，若超过了初始大小则继续进行分配
    *returnSize = 0;
    int** res = (int**)malloc(sizeof(int *) * base);
    *returnColumnSizes=(int*)malloc(sizeof(int)*base);
    //对数组进行升序排序
    for(int i = 0;i < numsSize;i++){
        for(int j = i + 1;j < numsSize;j++){
            if(nums[i] > nums[j]){
                swap(&nums[i], &nums[j]);
            }
        }
    }
    for(int i = 0;i < numsSize && nums[i] <= 0;i++){ //每一轮都是双指针从两边向中间靠拢
        if(i>0 && nums[i]==nums[i-1]){  //若与上一个数相等则直接跳过，避免重复  这里的i必须大于0 并且写在判断等于的前面
            continue;
        }
        int low = i + 1, high = numsSize - 1;
        while(low < high){
            if(nums[low] + nums[high] + nums[i] == 0 ){
                res[*returnSize] = (int*)malloc(sizeof(int) * 3);  //申请二维数组空间
                res[*returnSize][0] = nums[i];
                res[*returnSize][1] = nums[low];
                res[*returnSize][2] = nums[high];
                (*returnColumnSizes)[*returnSize] = 3;   //每一行元素个数
                (*returnSize)++;
                if(*returnSize==base){
                    base *= 2;
                    res = (int**)realloc(res,sizeof(int*) * base);
                    *returnColumnSizes = (int*)realloc(*returnColumnSizes,sizeof(int) * base);
                }
                //进行去重,并且包含指针移动
                int num1 = nums[low], num2 = nums[high];
                while(low < high && num1 == nums[low]){
                    low++;
                }
                while(low < high && num2 == nums[high]){
                    high--;
                }
            }else if(nums[low] + nums[high] < -nums[i]){   //小于目标，则将小的向右移动
                low++;
            }else{   //大于目标则将大的向左移动
                high--;
            }
        }
    }
    return res;
}

31.下一个排列

整数数组的一个 排列 就是将其所有成员以序列或线性顺序排列。

例如，arr = [1,2,3] ，以下这些都可以视作 arr 的排列：[1,2,3]、[1,3,2]、[3,1,2]、[2,3,1] 。
整数数组的 下一个排列 是指其整数的下一个字典序更大的排列。更正式地，如果数组的所有排列根据其字典顺序从小到大排列在一个容器中，那么数组的 下一个排列 就是在这个有序容器中排在它后面的那个排列。如果不存在下一个更大的排列，那么这个数组必须重排为字典序最小的排列（即，其元素按升序排列）。

例如，arr = [1,2,3] 的下一个排列是 [1,3,2] 。
类似地，arr = [2,3,1] 的下一个排列是 [3,1,2] 。
而 arr = [3,2,1] 的下一个排列是 [1,2,3] ，因为 [3,2,1] 不存在一个字典序更大的排列。
给你一个整数数组 nums ，找出 nums 的下一个排列。

必须 原地 修改，只允许使用额外常数空间。

void swap(int *a, int *b){
    int temp = *a;
    *a = *b;
    *b = temp;
}

void nextPermutation(int* nums, int numsSize){
    int low, high, flag = 0;  //flag = 0未找到升序对，下一个排列应为原排列的逆序
    for(int i = numsSize - 1; i >= 1;i--){   //从后向前寻找第一个升序对
        if(nums[i - 1] < nums[i]){
            low = i - 1;
            high = i;
            flag = 1;
            break;
        }
    }
    if(flag == 0){  //将该数组逆置
        int i = 0, j = numsSize - 1;
        while(i < j){
            swap(&nums[i], &nums[j]);
            i++;
            j--;
        }
    }else{  //在(high,end)中从后向前查找第一个大于nums[low]的元素，并进行交换，然后将(high,end)逆置为升序
        for(int i = numsSize - 1;i >= high;i--){
            if(nums[i] > nums[low]){
                swap(&nums[i], &nums[low]);
                break;
            }
        }
        int i = high, j = numsSize - 1;
        while(i < j){
            swap(&nums[i], &nums[j]);
            i++;
            j--;
        }
    }
}

33.搜索旋转排序数组（二分查找）

整数数组 nums 按升序排列，数组中的值 互不相同 。
在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。
给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。
你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4
示例 2：

输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1
示例 3：

输入：nums = [1], target = 0
输出：-1

提示：

1 <= nums.length <= 5000
-104 <= nums[i] <= 104
nums 中的每个值都 独一无二
题目数据保证 nums 在预先未知的某个下标上进行了旋转
-104 <= target <= 104

注意：对有序或者基本有序的搜索，基本使用二分搜索及其变种

int search(int* nums, int numsSize, int target){
    int low = 0, high = numsSize - 1;
    if(numsSize == 1){
        if(nums[0] == target){   //长度为1的情况
            return 0;
        }else{
            return -1;
        }
    }
    while(low <= high){  //要取等于
        int mid = (low + high) / 2;   //生成两个区间(low, mid) (mid, high)
        if(nums[mid] == target){
            return mid;
        }
        if(nums[low] <= nums[mid]){   //判断哪个区间是单调的
            if(target <= nums[mid] && target >= nums[low]){  //这里要加等于号，否则在边界的就取不到了
                high = mid - 1;
            }else{
                low = mid + 1;
            }
        }else{  //右区间单调
            if(target <= nums[high] && target >= nums[mid]){
                low = mid + 1;
            }else{
                high = mid - 1;
            }
        }
    }
    return -1; 
}

注意边界条件