第一章 数组

一、数组理论

1. 数组元素有哪些特性？
2. 如何理解数组在内存中的存储方式？
3. 二维数组的物理地址是否连续？

ANS1：C语言中，数组下标从“0”开始。数组中的元素可被随机存取，但插入和删除操作较复杂。补充：为什么数组下标不从“1”开始？因为数字的日常意义和进制意义冲突的缘故，带来理解上和使用上的便利也是相对的。前者自“1”开始便于理解元素在数组中的位置，但不利于理解元素在数组中的偏移量；后者恰恰相反。事实上，使用前者会在数组存储和调用中带来更多的不便，所以各类编程语言通常规定数组下标从“0”开始。

ANS2：数组是内存中逻辑意义上连续的地址，物理意义上不一定连续。（详见《操作系统原理》）其本质是用户通过编程语言在内存中申请的一段地址，而地址是用于存储数据的“容器”，故数组中的元素无法在物理意义上被删除，只能被新数据覆盖。

ANS3：各类编程语言因内存管理方式的不同，二维数组的物理地址连续性存在差异。如在C++语言中二维数组的物理地址连续，而在java语言中二维数组的物理地址却不连续。

---

二、数组应用

本章应用题共5道。

1. 二分查找（已掌握） LeetCode.704
2. 移除元素（需补充） LeetCode.27
3. 有序数组的平方（需实现） LeetCode.977
4. 长度最小的子数组（需实现） LeetCode.209
5. 螺旋矩阵Ⅱ（需实现） LeetCode.59

1.二分查找

描述：在给定升序数组中寻找一个特定值并返回对应元素下标。

思路：元素值是否重复？元素大小是否存在上限？假设元素值不重复且元素大小存在上限则应自然联想到使用二分法。

// 明确左右区间的开闭
int search(int* nums, int numsSize, int target) {
    int left = 0;
    int right = numsSize - 1;
    int middle = 0;
    // 确保区间不为空
    while (left <= right) {
        // 更新mid值
        middle = (left + right) / 2;
        // 判断tar值所在子区间
        if (nums[middle] > target) {
            right = middle - 1;
        } else if (nums[middle] < target) {
            left = middle + 1;
        } else if (nums[middle] == target) {
            return middle;
        }
    }
    return -1;
}

2.移除元素

描述：原地移除给定数组中的某一特定值，并输出新数组及其长度。

思路：要求原地移除意味着无法使用标记数组法，且题目提示数组内元素相对顺序可变，故考虑使用双指针法。①首尾指针法：每次首指针扫描到val值后从尾指针选定一个非val值元素覆盖首指针当前位置指定的元素，然后尾指针前移一位。当首指针和尾指针相遇时输出并结束算法。②快慢指针法：设置快慢指针同时从0号元素开始遍历，其中慢指针指向下一个非val值元素在数组中的绝对位置，快指针用于寻找下一个非val值元素以覆盖当前慢指针所指向的元素。当快指针遍历到数组底部时算法结束。注意，使用快慢指针法不会改变数组元素的相对位置。

int removeElement(int* nums, int numsSize, int val) {
    // 定义快慢指针
    int slow = 0;
    int fast = 0;
    // 明确退出条件
    for (; fast < numsSize; fast++) {
        // 寻找非val值元素并覆盖慢指针位置
        if (nums[fast] != val) {
            nums[slow] = nums[fast];
            slow++;
        }
    }
    // 返回数组大小
    return slow;
}

3.有序数组的平方

描述：将给定的非严格递增数组的元素平方也按非严格递增顺序输出。

思路：题目原本描述的“非递减顺序”乍一听很让人迷惑。nums = [5, 4, 2, 3, 1] 是否也属于“非递减顺序”呢？从题解来看其实是不属于的，题目要求即“非严格递增”。按此思路容易联想到先平方后排序的暴力解，但不妨思考利用数组的有序条件：数组在两侧实质上是有序的，即左侧非严格递减，右侧非严格递增，可以考虑使用首尾指针法。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* sortedSquares(int* nums, int numsSize, int* returnSize) {
    // 此处returnSize变量有何特殊含义？
    *returnSize = numsSize;
    int right = numsSize - 1;
    int left = 0;

    int* ans = (int*)malloc(sizeof(int) * numsSize);
    for (int index = numsSize - 1; index >= 0; index--) {
        int lSquare = nums[left] * nums[left];
        int rSquare = nums[right] * nums[right];
        // 比较首尾指针指向元素的平方大小
        if (lSquare > rSquare) {
            ans[index] = lSquare;
            left++;
        } else {
            ans[index] = rSquare;
            right--;
        }
    }
    return ans;
}

4.长度最小的子数组

描述：返回给定数组中满足元素和大于等于特定值的连续子序列长度。

思路：本题很容易联想到枚举所有连续子序列的暴力解法，但枚举法在找到最小子序列前进行了大量不必要的判断操作。考虑到若最小子序列存在并要返回其长度，则需判断其起始位置和终止位置，若采用固定起始位置并寻找终止位置的思路，很容易走向同样使用枚举法的暴力解，不妨转换思路，首先通过for循环确定终止位置，当数组首元素到终止位置的序列和大于等于val值时开始移动起始位置，以确定最小子序列。这种方法被称为滑动窗口法，本质上是一对标记起始位置和终止位置的双指针。

int minSubArrayLen(int target, int* nums, int numsSize) {
    //初始化最小长度为INT_MAX
    int minLength = INT_MAX;
    int sum = 0;

    int left = 0, right = 0;
    //右边界向右扩展
    for (; right < numsSize; ++right) {
        sum += nums[right];
        //当sum的值大于等于target时，保存长度，并且收缩左边界
        while (sum >= target) {
            int subLength = right - left + 1;
            minLength = minLength < subLength ? minLength : subLength;
            sum -= nums[left++];
        }
    }
    //若minLength不为INT_MAX，则返回minLnegth
    return minLength == INT_MAX ? 0 : minLength;
}

5.螺旋矩阵Ⅱ

描述：给定正整数n ，生成包含1到 n^2所有元素且元素按顺时针顺序螺旋排列的n*n正方形矩阵。

思路：本题思路相当明确，考察的核心并非算法而是过程模拟。首先应该明确的是每次循环所区分的边界条件，保证左右区间开闭性一致，即第一每次均是按顺时针方法遍历 n-1 个元素，下一轮循环中 n = n-1（有点类似于翻纸箱游戏，这样折叠的箱子即使不用胶带也很难打开）。

/**
 * 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) {
    //初始化返回的结果数组的大小
    *returnSize = n;
    *returnColumnSizes = (int*)malloc(sizeof(int) * n);
    //初始化返回结果数组ans
    int** ans = (int**)malloc(sizeof(int*) * n);
    int i;
    for (i = 0; i < n; i++) {
        ans[i] = (int*)malloc(sizeof(int) * n);
        (*returnColumnSizes)[i] = n;
    }

    //设置每次循环的起始位置
    int startX = 0;
    int startY = 0;
    //设置二维数组的中间值，若n为奇数。需要最后在中间填入数字
    int mid = n / 2;
    //循环圈数
    int loop = n / 2;
    //偏移数
    int offset = 1;
    //当前要添加的元素
    int count = 1;

    while (loop) {
        int i = startX;
        int j = startY;
        //模拟上侧从左到右
        for (; j < startY + n - offset; j++) {
            ans[startX][j] = count++;
        }
        //模拟右侧从上到下
        for (; i < startX + n - offset; i++) {
            ans[i][j] = count++;
        }
        //模拟下侧从右到左
        for (; j > startY; j--) {
            ans[i][j] = count++;
        }
        //模拟左侧从下到上
        for (; i > startX; i--) {
            ans[i][j] = count++;
        }
        //偏移值每次加2
        offset += 2;
        //遍历起始位置每次+1
        startX++;
        startY++;
        loop--;
    }
    //若n为奇数需要单独给矩阵中间赋值
    if (n % 2)
        ans[mid][mid] = count;

    return ans;
}