1、数组相关

「已注销」

于 2021-06-19 15:16:34 发布

阅读量277

点赞数

本文链接：https://blog.csdn.net/God__Rain/article/details/118054255

版权

二分查找双指针法滑动窗口数组算法螺旋矩阵

关键词由CSDN通过智能技术生成

文章目录

数组
1、二分查找
- leecode 704. 二分查找
2、双指针法(快慢指针)
- leetcode 27. 移除元素
3、双指针法(左右指针)
- leetcode 977.有序数组的平方
4、滑动窗口(快慢指针)
- leetdoe 209. 长度最小的子数组
5、模拟过程
- leetcode 54. 螺旋矩阵
- leetcode 59. 螺旋矩阵 II

下一节：2、链表相关

数组

数组是存放在连续内存空间上的相同类型数据的集合。
数组可以方便的通过下标索引的方式获取到下标下对应的数据。
在这里插入图片描述

数组下标都是从0开始的。
数组内存空间的地址是连续的，二维数组在C/C++语言中是连续存储的参考博文

1、二分查找

leecode 704. 二分查找

leecode 704. 二分查找
输入数组有序，各个元素各不相同时，二分查找有两种方法：
1、 target 是在一个在左闭右闭的区间里，也就是[left, right]
区间的定义这就决定了二分法的代码应该如何写，因为定义target在[left, right]区间，所以有如下两点：

while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=
if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1

例如在数组：1,2,3,4,7,9,10中查找元素2，如图所示：
在这里插入图片描述
代码如下

int search(int* nums, int numsSize, int target){
    /* 定义左右边界 */
    int left = 0, right = numsSize - 1;
    /* 定义搜索区间为闭区间[left,right] */
    while (left <= right) {
        /* 1: mid = (left + right) / 2
         * 2: mid = left + (right - left) / 2
         * 第2种可以防止(left + right)直接相加数值过大越界的问题
         */
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else {
            return mid;
        }
    }
    return -1;
}

2、如果说定义 target 是在一个在左闭右开的区间里，也就是[left, right) ，

while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]

在数组：1,2,3,4,7,9,10中查找元素2，如图所示：（注意和方法一的区别）
在这里插入图片描述
代码如下

int search(int* nums, int numsSize, int target){
    /* 定义左右边界 */
    int left = 0, right = numsSize; //注意这里right为numsSize
    /* 定义搜索区间为闭区间[left,right] */
    while (left < right) {	//注意这里left < right
        /* 1: mid = (left + right) / 2
         * 2: mid = left + (right - left) / 2
         * 第2种可以防止(left + right)直接相加数值过大越界的问题
         */
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid;	//注意这里right = mid
        } else {
            return mid;
        }
    }
    return -1;
}

3、数组中有相同元素
之后再写

2、双指针法(快慢指针)

leetcode 27. 移除元素

leetcode 27. 移除元素
给定一个数组，要求原地删除元素值为target的元素，不能使用额外的空间；
那么维护一个快指针fastIndex，慢指针slowIndex：

nums[fastIndex] == target时，fastIndex++；
nums[fastIndex] != target时，fastIndex++, slowIndex++；

代码如下：

时间复杂度： $O (n)$
空间复杂度： $O (1)$

int removeElement(int* nums, int numsSize, int val) {
	int slowIndex = 0;
	for (int fastIndex = 0; fastIndex < numsSize; fastIndex++) {
		if (val != nums[fastIndex]) {
			nums[slowIndex++] = nums[fastIndex];
		}
	}
	return slowIndex;
}

暴力解如下：

时间复杂度： $O(n^2)$
空间复杂度： $O (1)$

int removeElement(int* nums, int numsSize, int val) {
	int size = numsSize;
    for (int i = 0; i < size ; i++) {
        if (nums[i] == val) { // 发现需要移除的元素，就将数组集体向前移动一位
            for (int j = i + 1; j < size; j++) {
                nums[j - 1] = nums[j];
            }
            i--; // 因为下表i以后的数值都向前移动了一位，所以i也向前移动一位
            size--; // 此时数组的大小-1
        }
    }
    return size;
}

3、双指针法(左右指针)

leetcode 977.有序数组的平方

leetcode 977.有序数组的平方
给你一个按非递减顺序排序的整数数组 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、暴力排序
每个数平方之后，排个序，代码如下：
这个时间复杂度是 $O (n + n l o g n)$ ，可以说是 $O (n l o g n)$ 的时间复杂度

int cmp(const void* a, const void* b) {
    return *(int*)a - *(int*)b;
}
int* sortedSquares(int* nums, int numsSize, int* returnSize){
    for (int i = 0; i < numsSize; i++) {
        nums[i] *= nums[i];
    }
    qsort(nums, numsSize, sizeof(int), cmp);
    *returnSize = numsSize;
    return nums;
}

2、左右指针法
这个时间复杂度是 $O (n)$
数组其实是有序的，只不过负数平方之后可能成为最大数了。
那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。
此时可以考虑双指针法了，i指向起始位置，j指向终止位置。
定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。
如果A[i] * A[i] < A[j] * A[j] 那么result[k–] = A[j] * A[j]; 。
如果A[i] * A[i] >= A[j] * A[j] 那么result[k–] = A[i] * A[i]; 。
在这里插入图片描述
代码如下：

int* sortedSquares(int* nums, int numsSize, int* returnSize) {
    int left = 0, right = numsSize - 1;
    int* res = (int*)calloc(numsSize, sizeof(int));
    *returnSize = numsSize;
    while (left <= right) {
        if (nums[left] * nums[left] < nums[right] * nums[right]) {
            res[--(*returnSize)] = nums[right] * nums[right];
            right--;
        } else {
            res[--(*returnSize)] = nums[left] * nums[left];
            left++;
        }
    }
    *returnSize = numsSize;
    return res;
}

4、滑动窗口(快慢指针)

leetdoe 209. 长度最小的子数组

leetdoe 209. 长度最小的子数组
给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。
示例：

输入：s = 7, nums = [2,3,1,2,4,3] 输出：2 解释：子数组 [4,3] 是该条件下的长度最小的子数组。

暴力解就是两个for循环
时间复杂度： $O(n^2)$
空间复杂度： $O (1)$

滑动窗口就是快慢指针
时间复杂度： $O (n)$
空间复杂度： $O (1)$

代码如下:

int minSubArrayLen(int target, int* nums, int numsSize) {
    int sum = 0; // 滑动窗口数值之和
    int left = 0; // 滑动窗口起始位置
    int subLength = 0; // 滑动窗口的长度
    int res = INT_MAX; //返回值
    for (int right = 0; right < numsSize; right++) {
        sum += nums[right];
        // 注意这里使用while，每次更新 i（起始位置），并不断比较子序列是否符合条件
        while (sum >= target) {
            subLength = right - left + 1;// 取子序列的长度
            res = res < subLength ? res : subLength;
            sum -= nums[left++]; // 这里体现出滑动窗口的精髓之处，不断变更i（子序列的起始位置）
        }
    }
    // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
    return res == INT_MAX ? 0 : res;
}

5、模拟过程

leetcode 54. 螺旋矩阵

leetcode 54. 螺旋矩阵
给你一个 m 行 n 列的矩阵 matrix ，请按照顺时针螺旋顺序，返回矩阵中的所有元素。
代码如下：

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* spiralOrder(int** matrix, int matrixSize, int* matrixColSize, int* returnSize){
    /* 输入矩阵为空，返回数组为空，返回数组大小为0 */
    if (matrixSize == 0) {
        *returnSize = 0;
        return NULL;
    }
    /* 返回数组大小 */
    *returnSize = matrixSize * matrixColSize[0];
    /* 定义返回数组 */
    int *nums = (int*)malloc(sizeof(int) * (*returnSize));
    /* 定义cur用于记录当前遍历的元素位置 */
    int cur = 0;
    /* 定义矩阵的上下边界 */
    int up = 0, down = matrixSize - 1;
    /* 定义矩阵的左右边界 */
    int left = 0, right = matrixColSize[0] - 1;
    while (cur < *returnSize) {
        /* 从左到右 */
        for (int i = left; cur < *returnSize && i <= right; i++) {
            nums[cur++] = matrix[up][i];
        }
        up++;
        /* 从上到下 */
        for (int i = up; cur < *returnSize && i <= down; i++) {
            nums[cur++] = matrix[i][right];
        }
        right--;
        /* 从右到左 */
        for (int i = right; cur < *returnSize && i >= left; i--) {
            nums[cur++] = matrix[down][i];
        }
        down--;
        /* 从下到上 */
        for (int i = down; cur < *returnSize && i >= up; i--) {
            nums[cur++] = matrix[i][left];
        }
        left++;
    }
    return nums;
}

leetcode 59. 螺旋矩阵 II

leetcode 59. 螺旋矩阵 II
给定一个正整数 n，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。
示例:

输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

本地无具体算法，就是模拟数据写入或者读取的过程，输入为二维数组
模拟顺时针画矩阵的过程:

填充上行从左到右
填充右列从上到下
填充下行从右到左
填充左列从下到上

由外向内一圈一圈这么画下去。
代码如下：

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int** generateMatrix(int n, int* returnSize, int** returnColumnSizes){
    /* 返回数组的行数，为n */
    *returnSize = n;
    /* 返回数组中每行的列数，均为n */
    *returnColumnSizes = (int*)malloc(sizeof(int) * n);
    /* 定义返回数组 */
    int** matrix = (int**)malloc(sizeof(int*) * n);
    for (int i = 0; i < n; i++) {
        matrix[i] = (int*)malloc( sizeof(int) * n);
        (*returnColumnSizes)[i] = n;
    }
    /* 定义cur用于记录当前遍历的元素位置 */
    int cur = 1;
    /* 定义矩阵的上下边界 */
    int up = 0, down = n - 1;
    /* 定义矩阵的左右边界 */
    int left = 0, right = n - 1;
    while (cur <= n*n) {
        /* 从左到右 */
        for (int i = left; cur <= n*n && i <= right; i++) {
            matrix[up][i] = cur++;
        }
        up++;
        /* 从上到下 */
        for (int i = up; cur <= n*n && i <= down; i++) {
            matrix[i][right] = cur++;
        }
        right--;
        /* 从右到左 */
        for (int i = right; cur <= n*n && i >= left; i--) {
            matrix[down][i] = cur++;
        }
        down--;
        /* 从下到上 */
        for (int i = down; cur <= n*n && i >= up; i--) {
            matrix[i][left] = cur++;
        }
        left++;
    }
    return matrix;
}

下一节：2、链表相关

「已注销」

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
1、数组相关

文章目录数组1、二分查找leecode 704. 二分查找2、双指针法(快慢指针)leetcode 27. 移除元素3、双指针法(左右指针)leetcode 977.有序数组的平方4、滑动窗口(快慢指针)leetdoe 209. 长度最小的子数组5、模拟过程leetcode 54. 螺旋矩阵leetcode 59. 螺旋矩阵 II数组数组是存放在连续内存空间上的相同类型数据的集合。数组可以方便的通过下标索引的方式获取到下标下对应的数据。数组下标都是从0开始的。数组内存空间的地址是连续的，二维数组
复制链接

扫一扫