【数组——leetcode刷题记录（跟随代码随想录）】

704.二分查找

题目描述

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

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

注意

这道题目的前提是数组为有序数组，同时题目还强调数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的，这些都是使用二分法的前提条件。

思路

这是一个升序的整型数组，需要左边界和右边界，且根据中间值与target的值相比较决定边界的选择（向左或向右）。一般有两种解法，一种左闭右闭，还有左闭右开，这就决定了其中一些代码的不同。

自己的代码

class Solution {
    public int search(int[] nums, int target) { 
        int left = 0;
        int right = nums.length - 1;
        int mid = left + (right - left) / 2;
        while (left <= right) {
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] < target) {
                left = mid;
                mid = left + (right - left) / 2;
            } else {
                right = mid;
                mid = left + (right - left) / 2;
            }
        }
        return -1;
    }
}

最后运行显示超出时间限制。

算例解法

下面是根据所提供正确解法得到的。（左闭右闭）

class Solution {
    public int search(int[] nums, int target) { 
        int left = 0;
        int right = nums.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1;
    }
}

主要自己出错在定义mid的位置，应该放在while循环的第一句，而不用在判断中连续用两次，同时left赋值也是mid+1，因为肯定进入判断了，肯定不相等了。
如果是左闭右开，那就主要改成 right = nums.length; (left < right) ; right = mid;

相关题目推荐

• 35.搜索插入位置
• 34.在排序数组中查找元素的第一个和最后一个位置
• 69.x 的平方根
• 367.有效的完全平方数

27.移除元素

题目描述

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

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

思路

使用快慢指针，慢指针用来存储不等于val的其它所有值，快指针用来遍历所有值。

自己的代码

使用快慢指针

class Solution {
    public int removeElement(int[] nums, int val) {
        //快慢指针
        int slow = 0;
        int quick = 0;
        int len = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[quick] != val) {
                nums[slow] = nums[quick];
                slow++;
                len++;
            }
            quick++;
        }
        return len;
    }
}

算例解法（快慢指针）

class Solution {
    public int removeElement(int[] nums, int val) {

        // 快慢指针
        int fastIndex = 0;
        int slowIndex;
        for (slowIndex = 0; fastIndex < nums.length; fastIndex++) {
            if (nums[fastIndex] != val) {
                nums[slowIndex] = nums[fastIndex];
                slowIndex++;
            }
        }
        return slowIndex;
    }
}

该算例首先直接用slowIndex代表长度了，直接让fastIndex当作i了，代码更加简洁。

暴力解法

两层for循环，时间复杂度为O(n^2)

class Solution {
    public int removeElement(int[] nums, int val) {
        //暴力解法
        int len = nums.length;
        for (int i = 0; i < len; i++) {
            if (nums[i] == val) {
                for (int j = i + 1; j < len; j++) {
                    nums[j - 1] = nums[j];
                }
                i--;
                len--;
            }
        }
        return len;
    }
}

相关题目推荐

• 26.删除排序数组中的重复项
• 283.移动零
• 844.比较含退格的字符串
• 977.有序数组的平方

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]

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

思路

数组按递增顺序排序，但左侧的复数的平方可能大于右侧的正数，总之最大的平方数只会出现在两侧，故使用双指针比较两侧的数，并按大小依次从数组的尾部存入。

自己的代码

class Solution {
    public int[] sortedSquares(int[] nums) {
        int first = 0;
        int last = nums.length - 1;
        int index = nums.length - 1;
        while (first <= last) {
            if (nums[first] * nums[first] <= nums[last] * nums[last]) {
                nums[index] = nums[last] * nums[last];
                last--;
            } else {
                nums[index] = nums[first] * nums[first];
                first++;
            }
            index--;
        }
        return nums;
    }
}

输入
[-4,-1,0,3,10]
输出
[0,65536,256,16,100]
预期结果
[0,1,9,16,100]
出现了问题。感觉就是没有创建新数组的原因。因为如果没有新数组，之前平方数也可以被再次平方！导致更大的数了。

算例解答

class Solution {
    public int[] sortedSquares(int[] nums) {
        int first = 0;
        int last = nums.length - 1;
        int index = nums.length - 1;
        int[] result = new int[nums.length];
        while (first <= last) {
            if (nums[first] * nums[first] <= nums[last] * nums[last]) {
                result[index--] = nums[last] * nums[last--];
            } else {
                result[index--] = nums[first] * nums[first++];
            }
        }
        return result;
    }
}

创建了新的数组result，同时直接将index–，last–，first++放入数组名中，因为是先执行后加减，简化了代码。

暴力解法

就是每个数平方返回原数组后，进行排序。快捷排序或者冒泡排序都可。

209.长度最小的子数组

题目描述

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

示例 1：

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

示例 2：

输入：target = 4, nums = [1,4,4]
输出：1

示例 3：

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

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

思路

移动范围，同样需要两个指针，范围根据是否大于等于target进行动态调整。右侧指针需要遍历到最后。可称为滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

算例解答

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
         int left = 0;
         int sum = 0;
         int result = Integer.MAX_VALUE;
         for (int right = 0; right < nums.length; right++) {
             sum += nums[right];
             while (sum >= target) {
                 result = Math.min(result, right - left + 1);
                 sum -= nums[left++];
             }
         }
         return result == Integer.MAX_VALUE ? 0 : result;
    }
}

暴力解法

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
         int result = Integer.MAX_VALUE;
         int subLength = 0;
         for (int i = 0; i < nums.length; i++) {
             int sum = 0;
             for (int j = i; j < nums.length; j++) {
                 sum += nums[j];
                 if (sum >= target) {
                     subLength = j - i + 1;
                     result = result < subLength ? result : subLength;
                     break;  // 因为我们是找符合条件最短的子序列，所以一旦符合条件就break
                 }
             }
         }
         return result == Integer.MAX_VALUE ? 0 : result;
    }
}

相关题目推荐

• 904.水果成篮
• 76.最小覆盖子串

59.螺旋矩阵II

题目描述

给你一个正整数 n ，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。
输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]
输入：n = 1
输出：[[1]]

思路

在面试中出现频率较高,考察对代码的掌控能力。每画一条边都要坚持一致的左闭右开，或者左开又闭的原则，这样这一圈才能按照统一的规则画下来。

算例解答

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] res = new int[n][n];
        // 循环次数
        int loop = n / 2;
        // 定义每次循环起始位置
        int startX = 0;
        int startY = 0;
        // 定义偏移量
        int offset = 1;
        //定义填充数字
        int count = 1;
        // 定义中间weiz
        int mid = n / 2;
        while (loop > 0) {
            int i = startX;
            int j = startY;
            // 模拟上侧从左到右
            for (; j < startY + n - offset; ++j) {
                res[startX][j] = count++;
            }
            // 模拟右侧从上到下
            for (; i < startX + n - offset; ++i) {
                res[i][j] = count++;
            }
            // 模拟下侧从右到左
            for (; j > startY; j--) {
                res[i][j] = count++;
            }
            // 模拟左侧从下到上
            for (; i > startX; i--) {
                res[i][j] = count++;
            }
            loop--;
            startX += 1;
            startY += 1;
            offset += 2;
        }
        if (n % 2 == 1) {
            res[mid][mid] = count;  // 奇数的话最中间值定义
        }
        return res;
    }
}

相关题目推荐

• 54.螺旋矩阵
• 剑指Offer 29.顺时针打印矩阵