数组面试题总结

最新推荐文章于 2021-09-17 11:40:10 发布
最新推荐文章于 2021-09-17 11:40:10 发布
阅读量367 收藏
点赞数 1
分类专栏： 剑指Offer题解 LeetCode题解 文章标签： leetcode 剑指offer 数组 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wardseptember/article/details/110291011
版权

文章目录

剑指 Offer 03. 数组中重复的数字

力扣链接

找出数组中重复的数字。

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

示例 1：

输入：
[2, 3, 1, 0, 2, 5, 3]
输出：2 或 3 
 

限制：

2 <= n <= 100000

解法

class Solution {
    public int findRepeatNumber(int[] nums) {
        Set<Integer> set = new HashSet<Integer>();
        int repeat = -1;
        for (int num : nums) {
            if (!set.add(num)) {
                repeat = num;
                break;
            }
        }
        return repeat;
    }
}

剑指 Offer 53 - I. 在排序数组中查找数字 I

力扣链接

统计一个数字在排序数组中出现的次数。

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8
输出: 2
示例 2:

输入: nums = [5,7,7,8,8,10], target = 6
输出: 0
 

限制：

0 <= 数组长度 <= 50000

解法

用二分法找到第一次出现target的位置，然后遍历即可。

class Solution {
    public int search(int[] nums, int target) {
        int firstIndex = -1;
        if (nums.length == 0 || nums[0] > target) {
            return 0;
        }
        int low = 0, high = nums.length - 1;
        // 用二分查找，找到第一次出现target的位置
        while (low <= high) {
            int mid = low + ((high - low) >> 1);
            if (nums[mid] >= target) {
                if (mid == 0 || (nums[mid] == target && nums[mid - 1] < target)) {
                    firstIndex = mid;
                    break;
                }
                else {
                    high = mid - 1;
                } 
            }
            else {
                low = mid + 1;
            }
        }
        if (firstIndex != -1 && nums[firstIndex] == target) {
            if (firstIndex == nums.length - 1) {
                return 1;
            }
            else {
                // 往下遍历找到第二次出现target 的位置
                for (int i = firstIndex + 1; i < nums.length; ++i) {
                    if (nums[i] != target) {
                        return i - firstIndex; // i - 1 - firstIndex + 1
                    }
                    if (i == nums.length - 1 && nums[i] == target) {
                        return i - firstIndex + 1;
                    }
                }
            }
        }
        return 0;
    }
}

二分查找另一种写法

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

剑指 Offer 53 - II. 0～n-1中缺失的数字

力扣链接

一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。

示例 1:

输入: [0,1,3]
输出: 2
示例 2:

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

限制：

1 <= 数组长度 <= 10000

解法

1 = 1 ^ 2 ^ 2;三个数做异或运算会除去相同的数。

class Solution {
    public int missingNumber(int[] nums) {
        int result = 0;
        for (int i = 0; i < nums.length; ++i) {
            result = result ^ i ^ nums[i];
        }
        return result ^ nums.length;
    }
}

等差数列

class Solution {
    public int missingNumber(int[] nums) {
        int n = nums.length;
        int sum = (n + 1) * n / 2;
        for (int num : nums) {
            sum -= num;
        }
        return sum;
    }
}

二分法

class Solution {
    public int missingNumber(int[] nums) {
        int i = 0, j = nums.length - 1;
        while (i <= j) {
            int mid = i + ((j - i) >> 1);
            if (nums[mid] == mid) {
                i = mid + 1;
            } else {
                j = mid - 1;
            }
        }
        return i;
    }
}

移动零

283. 移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

示例:

输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:

必须在原数组上操作，不能拷贝额外的数组。
尽量减少操作次数。

解法1

class Solution {
    public void moveZeroes(int[] nums) {
        int index = 0;
        for (int num : nums) {
            if (num != 0) {
                nums[index++] = num;
            }
        }
        while (index < nums.length) {
            nums[index++] = 0;
        }
    }
}

解法2

class Solution {
    public void moveZeroes(int[] nums) {
        int index = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != 0) {
                nums[index++] = nums[i];
                if (i != index - 1) {
                    nums[i] = 0;
                }
            }
        }
    }
}

最大连续1的个数

力扣链接

给定一个二进制数组， 计算其中最大连续1的个数。

示例 1:

输入: [1,1,0,1,1,1]
输出: 3
解释: 开头的两位和最后的三位都是连续1，所以最大连续1的个数是 3.
注意：

输入的数组只包含 0 和1。
输入数组的长度是正整数，且不超过 10,000。

解法

class Solution {
    public int findMaxConsecutiveOnes(int[] nums) {
        int max = 0, cur = 0;
        for (int x : nums) {
            cur = x == 0 ? 0 : cur + 1;
            max = Math.max(max, cur);
        }
        return max;
    }
}

剑指 Offer 04. 二维数组中的查找

力扣链接

在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

示例:

现有矩阵 matrix 如下：

[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。

给定 target = 20，返回 false。

 

限制：
0 <= n <= 1000
0 <= m <= 1000

解法

class Solution {
    public boolean findNumberIn2DArray(int[][] matrix, int target) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return false;
        }
        int m = matrix.length, n = matrix[0].length;
        int i = 0, j = n - 1;
        while (i < m && j >= 0) {
            int tmp = matrix[i][j];
            if (tmp > target) {
                j--;
            } else if (tmp < target) {
                i++;
            } else {
                return true;
            }
        }
        return false;
    }
}

有序矩阵中第K小的元素

378. 有序矩阵中第K小的元素

给定一个 n x n 矩阵，其中每行和每列元素均按升序排序，找到矩阵中第 k 小的元素。
请注意，它是排序后的第 k 小元素，而不是第 k 个不同的元素。

示例：

matrix = [
   [ 1,  5,  9],
   [10, 11, 13],
   [12, 13, 15]
],
k = 8,

返回 13。

提示：
你可以假设 k 的值永远是有效的，1 ≤ k ≤ n2 。

二分查找法

class Solution {
    public int kthSmallest(int[][] matrix, int k) {
        int m = matrix.length, n = matrix[0].length;
        int left = matrix[0][0], right = matrix[m - 1][n - 1];
        while (left <= right) {
            int mid = left + (right - left) / 2;
            int count = 0;
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n && matrix[i][j] <= mid; j++) {
                    count++;
                }
            }
            if (count < k) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return left;
    }
}

堆排序

维持一个小顶堆

class Solution {
    public int kthSmallest(int[][] matrix, int k) {
        int m = matrix.length, n = matrix[0].length;
        PriorityQueue<Tuple> pq = new PriorityQueue<Tuple>();
        for (int j = 0; j < n; ++j) {
            pq.offer(new Tuple(0, j, matrix[0][j]));
        }
        for (int i = 0; i < k - 1; ++i) {
            Tuple t = pq.poll();
            if (t.x == m - 1) {
                continue;
            }
            pq.offer(new Tuple(t.x + 1, t.y, matrix[t.x + 1][t.y]));
        }
        return pq.poll().val;
    }
    class Tuple implements Comparable<Tuple> {
        int x, y, val;
        public Tuple(int x, int y, int val) {
            this.x = x;
            this.y = y;
            this.val = val;
        }
        @Override
        public int compareTo(Tuple tuple) {
            return this.val - tuple.val;
        }
    }
}

剑指 Offer 29. 顺时针打印矩阵

力扣链接

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

示例 1：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
示例 2：

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]
 

限制：

0 <= matrix.length <= 100
0 <= matrix[i].length <= 100

解法

class Solution {
    public int[] spiralOrder(int[][] matrix) {
        if (matrix.length == 0) {
            return new int[0];
        }
        int row = 0, col = 0, m = matrix.length - 1, n = matrix[0].length - 1;
        int[] res = new int[(m+1) * (n+1)];
        int index = 0;
        while (true) {
            for (int i = col; i <= n; ++i) {
                res[index++] = matrix[row][i];
            }
            if (++row > m) {
                break;
            }
            for (int i = row; i <= m; ++i) {
                res[index++] = matrix[i][n];
            }
            if (--n < col) {
                break;
            }
            for (int i = n; i >= col; --i) {
                res[index++] = matrix[m][i];
            }
            if (--m < row) {
                break;
            }
            for (int i = m; i >= row; --i) {
                res[index++] = matrix[i][col];
            }
            if (++col > n) {
                break;
            }
        }
        return res;
    }
}

重塑矩阵

566. 重塑矩阵

在MATLAB中，有一个非常有用的函数 reshape，它可以将一个矩阵重塑为另一个大小不同的新矩阵，但保留其原始数据。

给出一个由二维数组表示的矩阵，以及两个正整数r和c，分别表示想要的重构的矩阵的行数和列数。

重构后的矩阵需要将原始矩阵的所有元素以相同的行遍历顺序填充。

如果具有给定参数的reshape操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。

示例 1:

输入: 
nums = 
[[1,2],
 [3,4]]
r = 1, c = 4
输出: 
[[1,2,3,4]]
解释:
行遍历nums的结果是 [1,2,3,4]。新的矩阵是 1 * 4 矩阵, 用之前的元素值一行一行填充新矩阵。
示例 2:

输入: 
nums = 
[[1,2],
 [3,4]]
r = 2, c = 4
输出: 
[[1,2],
 [3,4]]
解释:
没有办法将 2 * 2 矩阵转化为 2 * 4 矩阵。 所以输出原矩阵。
注意：

给定矩阵的宽和高范围在 [1, 100]。
给定的 r 和 c 都是正数。

解法

class Solution {
    public int[][] matrixReshape(int[][] nums, int r, int c) {
        int row = nums.length, col = nums[0].length;
        if (row * col != r * c) {
            return nums;
        }
        int[][] res = new int[r][c];
        int index = 0;
        for (int i = 0; i < r; i++) {
            for (int j = 0; j < c; j++) {
                res[i][j] = nums[index / col][index % col];
                index++;
            }
        }
        return res;
    }
}

错误的集合

645. 错误的集合

集合 S 包含从1到 n 的整数。不幸的是，因为数据错误，导致集合里面某一个元素复制了成了集合里面的另外一个元素的值，导致集合丢失了一个整数并且有一个元素重复。

给定一个数组 nums 代表了集合 S 发生错误后的结果。你的任务是首先寻找到重复出现的整数，再找到丢失的整数，将它们以数组的形式返回。

示例 1:

输入: nums = [1,2,2,4]
输出: [2,3]
注意:

给定数组的长度范围是 [2, 10000]。
给定的数组是无序的。

解法

第一个for循环将nums数组排好序，第二个for循环返回结果。

class Solution {
    public int[] findErrorNums(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            while (nums[i] != i + 1 && nums[nums[i] - 1] != nums[i]) {
                swap(nums, i, nums[i] - 1);
            }
        }
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != i + 1) {
                return new int[]{nums[i], i + 1};
            }
        }
        return null;
    }
    private void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}

寻找重复数

287. 寻找重复数

给定一个包含 n + 1 个整数的数组 nums，其数字都在 1 到 n 之间（包括 1 和 n），可知至少存在一个重复的整数。假设只有一个重复的整数，找出这个重复的数。

示例 1:

输入: [1,3,4,2,2]
输出: 2
示例 2:

输入: [3,1,3,4,2]
输出: 3
说明：

不能更改原数组（假设数组是只读的）。
只能使用额外的 O(1) 的空间。
时间复杂度小于 O(n2) 。
数组中只有一个重复的数字，但它可能不止重复出现一次。

双指针

把数组当成有环链表，此题变成寻找环入口。
详细题解https://leetcode-cn.com/problems/find-the-duplicate-number/solution/xun-zhao-zhong-fu-shu-by-leetcode-solution/

将这个题目给的特殊的数组当作一个链表来看，数组的下标就是指向元素的指针，把数组的元素也看作指针。如 0 是指针，指向 nums[0]，而 nums[0] 也是指针，指向 nums[nums[0]].

class Solution {
    public int findDuplicate(int[] nums) {
        int slow = nums[0], fast = nums[nums[0]];
        while (slow != fast) {
            slow = nums[slow];
            fast = nums[nums[fast]];
        }
        fast = 0;
        while (slow != fast) {
            slow = nums[slow];
            fast = nums[fast];
        }
        return slow;
    }
}

优美的排列 II

667. 优美的排列 II

给定两个整数 n 和 k，你需要实现一个数组，这个数组包含从 1 到 n 的 n 个不同整数，同时满足以下条件：

① 如果这个数组是 [a1, a2, a3, ... , an] ，那么数组 [|a1 - a2|, |a2 - a3|, |a3 - a4|, ... , |an-1 - an|] 中应该有且仅有 k 个不同整数；.

② 如果存在多种答案，你只需实现并返回其中任意一种.

示例 1:

输入: n = 3, k = 1
输出: [1, 2, 3]
解释: [1, 2, 3] 包含 3 个范围在 1-3 的不同整数， 并且 [1, 1] 中有且仅有 1 个不同整数 : 1
 

示例 2:

输入: n = 3, k = 2
输出: [1, 3, 2]
解释: [1, 3, 2] 包含 3 个范围在 1-3 的不同整数， 并且 [2, 1] 中有且仅有 2 个不同整数: 1 和 2
 

提示:

 n 和 k 满足条件 1 <= k < n <= 104.

解法

让前 k+1 个元素构建出 k 个不相同的差值，序列为：1 k+1 2 k 3 k-1 … k/2 k/2+1.

class Solution {
    public int[] constructArray(int n, int k) {
        int[] res = new int[n];
        res[0] = 1;
        for (int i = 1, interval = k; i <= k; i++, interval--) {
            res[i] = i % 2 == 1 ? res[i - 1] + interval : res[i - 1] - interval;
        }
        for (int i = k + 1; i < n; i++) {
            res[i] = i + 1;
        }
        return res;
    }
}

数组的度

697. 数组的度

给定一个非空且只包含非负数的整数数组 nums, 数组的度的定义是指数组里任一元素出现频数的最大值。

你的任务是找到与 nums 拥有相同大小的度的最短连续子数组，返回其长度。

示例 1:

输入: [1, 2, 2, 3, 1]
输出: 2
解释: 
输入数组的度是2，因为元素1和2的出现频数最大，均为2.
连续子数组里面拥有相同度的有如下所示:
[1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2]
最短连续子数组[2, 2]的长度为2，所以返回2.
示例 2:

输入: [1,2,2,3,1,4,2]
输出: 6
注意:

nums.length 在1到50,000区间范围内。
nums[i] 是一个在0到49,999范围内的整数。

解法

class Solution {
    public int findShortestSubArray(int[] nums) {
        Map<Integer, Integer> numsCount = new HashMap<>();
        Map<Integer, Integer> numsLastIndex = new HashMap<>();
        Map<Integer, Integer> numsFirstIndex = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int num = nums[i];
            numsCount.put(num, numsCount.getOrDefault(num, 0) + 1);
            numsLastIndex.put(num, i);
            if (!numsFirstIndex.containsKey(num)) {
                numsFirstIndex.put(num, i);
            }
        }
        int maxCount = 0;
        for (int num : nums) {
            maxCount = Math.max(maxCount, numsCount.get(num));
        }
        int result = nums.length;
        for (int num : nums) {
            int count = numsCount.get(num);
            if (count != maxCount) {
                continue;
            }
            result = Math.min(result, numsLastIndex.get(num) - numsFirstIndex.get(num) + 1);
        }
        return result;
    }
}

托普利茨矩阵

766. 托普利茨矩阵

如果一个矩阵的每一方向由左上到右下的对角线上具有相同元素，那么这个矩阵是托普利茨矩阵。

给定一个 M x N 的矩阵，当且仅当它是托普利茨矩阵时返回 True。

示例 1:

输入: 
matrix = [
  [1,2,3,4],
  [5,1,2,3],
  [9,5,1,2]
]
输出: True
解释:
在上述矩阵中, 其对角线为:
"[9]", "[5, 5]", "[1, 1, 1]", "[2, 2, 2]", "[3, 3]", "[4]"。
各条对角线上的所有元素均相同, 因此答案是True。
示例 2:

输入:
matrix = [
  [1,2],
  [2,2]
]
输出: False
解释: 
对角线"[1, 2]"上的元素不同。
说明:

matrix 是一个包含整数的二维数组。
matrix 的行数和列数均在 [1, 20]范围内。
matrix[i][j] 包含的整数在 [0, 99]范围内。
进阶:

如果矩阵存储在磁盘上，并且磁盘内存是有限的，因此一次最多只能将一行矩阵加载到内存中，该怎么办？
如果矩阵太大以至于只能一次将部分行加载到内存中，该怎么办？

解法

先检查上三角矩阵，然后检查下三角矩阵

class Solution {
    public boolean isToeplitzMatrix(int[][] matrix) {
        for (int i = 0; i < matrix[0].length; i++) {
            if (!check(matrix, matrix[0][i], 0, i)) {
                return false;
            }
        }
        for (int i = 1; i < matrix.length; i++) {
            if (!check(matrix, matrix[i][0], i, 0)) {
                return false;
            }
        }
        return true;
    }
    private boolean check(int[][] matrix, int expectValue, int row, int col) {
        if (row >= matrix.length || col >= matrix[0].length) {
            return true;
        }
        if (matrix[row][col] != expectValue) {
            return false;
        }
        return check(matrix, expectValue, row + 1, col + 1);
    }
}

数组嵌套

565. 数组嵌套

索引从0开始长度为N的数组A，包含0到N - 1的所有整数。找到最大的集合S并返回其大小，其中 S[i] = {A[i], A[A[i]], A[A[A[i]]], ... }且遵守以下的规则。

假设选择索引为i的元素A[i]为S的第一个元素，S的下一个元素应该是A[A[i]]，之后是A[A[A[i]]]... 以此类推，不断添加直到S出现重复的元素。

示例 1:

输入: A = [5,4,0,3,1,6,2]
输出: 4
解释: 
A[0] = 5, A[1] = 4, A[2] = 0, A[3] = 3, A[4] = 1, A[5] = 6, A[6] = 2.

其中一种最长的 S[K]:
S[0] = {A[0], A[5], A[6], A[2]} = {5, 6, 2, 0}
 

提示：

N是[1, 20,000]之间的整数。
A中不含有重复的元素。
A中的元素大小在[0, N-1]之间。

解法

class Solution {
    public int arrayNesting(int[] nums) {
        int max = 0;
        for (int i = 0; i < nums.length; i++) {
            int count = 0;
            for (int j = i; nums[j] != -1; ) {
                count++;
                int t = nums[j];
                nums[j] = -1;
                j = t;
            }
            max = Math.max(count, max);
        }
        return max;
    }
}

最多能完成排序的块

769. 最多能完成排序的块

数组arr是[0, 1, …, arr.length - 1]的一种排列，我们将这个数组分割成几个“块”，并将这些块分别进行排序。之后再连接起来，使得连接的结果和按升序排序后的原数组相同。

我们最多能将数组分成多少块？

示例 1:

输入: arr = [4,3,2,1,0]
输出: 1
解释:
将数组分成2块或者更多块，都无法得到所需的结果。
例如，分成 [4, 3], [2, 1, 0] 的结果是 [3, 4, 0, 1, 2]，这不是有序的数组。
示例 2:

输入: arr = [1,0,2,3,4]
输出: 4
解释:
我们可以把它分成两块，例如 [1, 0], [2, 3, 4]。
然而，分成 [1, 0], [2], [3], [4] 可以得到最多的块数。
注意:

arr 的长度在 [1, 10] 之间。
arr[i]是 [0, 1, ..., arr.length - 1]的一种排列。

解法

class Solution {
    public int maxChunksToSorted(int[] arr) {
        if (arr == null) {
            return 0;
        }
        int result = 0;
        int right = arr[0];
        for (int i = 0; i < arr.length; i++) {
            right = Math.max(right, arr[i]);
            if (right == i) {
                result++;
            }
        }
        return result;
    }
}

欢迎关注我的公众号呦，率先更新内容，并且后续还有一些源码级的免费教程推出。


wardseptember
关注
专栏目录
2024年Unity 面试题 |五萬字 二佰道| Unity面试题大全，面试题总结【全网最全，收藏一篇足够面试】
努力前行，总会成为自己心中的那道光
02-23 12万+
正所谓 金三银四 ，又到了找工作的大好时机了，不知道大家有没有意向找一份更好的工作呢~ 之前写了很多Unity的学习和实例文章，但是面试题部分还没有一个系统的整理。 那本篇文章就来整理一下Unity中一些常见的面试题，说不准就会面试的时候就会遇到！ 本篇文章会将Unity所有方面的面试资料都融会贯通，绝对是2022年Unity面试领域最实用的文章啦！
数组常见面试题
qq_45661125的博客
09-24 1368
数组中数字出现的次数数组中出现次数超过一半的数字数组中有些元素出现两次而其他元素出现一次。找到所有出现两次的元素。数组中两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字在一个数组 nums 中除一个数字只出现一次之外，其他数字都出现了三次。请找出那个只出现一次的数字。 数组中出现次数超过一半的数字 https://leetcode-cn.com/problems/shu-zu-zhong-chu-xian-ci-shu-chao-guo-yi-ban-de-shu-zi-lcof/ c
关于数组的几道面试题
nbfcome的专栏
10-20 1069
关于数组的几道面试题  分类： C/C++     数组是最基本的数据结构，关于数组的面试题也屡见不鲜，本文罗列了一些常见的面试题，仅供参考，如果您有更好的题目或者想法，欢迎留言讨论。目前有以下18道题目，如有好的题目，随时更新。  数组求和 求数组中的最大值和最小值 求数组中的最大值和次大值 求数组中出现次数超过一半的元素 求数组中元素的最短距离 求两个有序数组的
数组相关面试题
geng2568的博客
03-24 508
编写冒泡排序和选择排序 给一个乱序数组，使得奇数放在前面，偶数放在数组后面，并且保证奇偶数在原数组的相对位置不变 第一题、 //冒泡排序时间复杂度是O(n^2) public static void bubbleSort(int[] arr) { boolean didSwap; for (int i = 0, len = arr.length; i <...
面试题数组篇(1)
weixin_30902251的博客
05-23 152
前端面试中，数组是少不了的。因为数组使用度比较频繁，我在项目中就经常使用。JavaScript拼接Html，数据结构计算，等等。 汇总一下面试中数组会问到的几个问题，这个问题在面试经常被问到，但是一般同学都不太熟悉。不全面的大家可以留言补充。 1、数组有哪些方法，常用的有哪几个 Array 对象属性 属性描述 constructor 返回对创建此对象的...
面试题总结：数组和链表的区别 数组和链表.pdf
04-18
数组和链表的区别 在计算机科学中，数组和链表是两种基本的数据结构，它们都广泛应用于软件开发和算法设计中。然而，数组和链表有着根本的区别，这些区别决定了它们在不同的场景下的应用。 数组 数组是一种连续...
js数组类面试题总结及答案
weixin_43844440的博客
12-15 988
1、JavaScript不借助第三个变量实现交换a,b变量值 1.ES6结构赋值语法，允许我们提取数组和对象的值，对变量进行赋值 [a,b] = [b,a]; 2.直接交换a和b的变量值 a = [b,b=a][0]; 3.先把a变成一个（对象，数组），最后赋值 a = {a:b,b:a}; b = a.b; a = a.a; a = [a,b]; b = a[0]; a = a[1]; 4.让a先变成a与b的‘和’（也可以换成a和b的差） ‘和’减去b巧妙的得到了a的变量值赋予b 再通过‘和’减去
array 前端面试题_前端常见面试题（一）js数组大全
weixin_39813574的博客
12-24 816
js操作数组方法，目前总结了：22 + 11种。ES5中的已有的方法???? 22个???? Array.isArray(arr) :ES5提供的判断一个值是否为数组的方法，该方法没有instanceof由于环境不同导致准确的问题。可能有兼容性问题Object.prototype.toString.call(value) == "[object Array]"。使用该方法没有兼容性，也是常用的方法????fi...
C语言面试题总结汇总经典.pdf
最新发布
03-29
根据给定文件的信息，我们可以提炼出一系列与...以上是对文件中提到的部分面试题的详细解析，这些题目不仅考察了应聘者的基础编程能力，还考验了解决实际问题的能力，对于准备C语言面试的人来说是非常有价值的练习。
数组的常见面试题
05-26 1838
1排序1.1冒泡1.2选择1.3插入1.4希尔1.5快速2查找2.1线性查找2.2二分查找2.2.1迭代2.2.2递归3求最值3.1求最大值3.2求最小值3.3求次最大值3.4求次最小值4归并4.1有序归并4.2无序归并5去重
数组常见的面试题
weixin_30621919的博客
03-31 109
案例:数组{12,34,4567,22} 转换后1222344567 解题思路:对数组进行排序，后将数组转换为字符串 package com.demo; /** * * {12,34,4567,22} * 1222344567 * @author Administrator * */ public class ArraySort { ...
数组常见面试题目
程文英
09-17 680
**1. 提示用户输入数组的长度，以及数组每一项的值，然后输出该数组** var len = +prompt("请输入其数组的长度1") if (!len || len < 0) { alert("请重新进行输入") } else { var arr = new Array(len) for (var i = 0; i < arr.length; i++) { arr[i] = prom...
(二)有关数组的面试题
白天不懂夜的黑
01-01 1092
数组去重(常考) 方法一(暴力) var arr = [1, 23, 1, 1, 1, 3, 23, 5, 6, 7, 9, 9, 8, 5]; function deleteItem(arr) { for (let i = 0; i &lt; arr.length; i++) { for (let j = i + 1; j &lt; arr.length; j++) {...
数组相关的面试题
weixin_34242509的博客
05-09 91
数组相关: 1. 如何把一段逗号分割的字符串转换成一个数组? String 类的split方法可以根据给定正则表达式的匹配拆分字符串，故而可以把字符串分离成单个字符的形式。StringTokenizer 类：string tokenizer 类允许应用程序将字符串分解为标记。tokenization 方法比 StreamTokenizer 类所使用的方法更简单。StringTok...
数组有关面试题
我欲乘风破浪
01-09 185
如何判断一个数组是数组 数组有哪些方法 有哪些方法可以截取数组 数组中迭代方法对于null/undefined的处理情况 数组去重 数组的扁平化 解析概要
面试题(一)数组
生活要快乐 - 魏言
06-17 786
面试, 碰到这么一个古怪笔试题, 花了10分钟才看懂题目, 要了两张草稿纸也没作出来, 汗!无脸见人! 大家来讨论一下题目: 将一个交错数据合并为一个一维数组输入: strJaggedArray[][], 由多个一维数组(长度不定,个数不定)组成的交错数组输出: strArray[], 由strJaggedArray[r][c]中的元素以"&"为分隔符拼合而成, 是strJaggedArray
【程序员面试宝典】数组相关面试题
double_happiness的博客
07-02 964
1、像素翻转 有一副由NxN矩阵表示的图像，这里每个像素用一个int表示，请编写一个算法，在不占用额外内存空间的情况下(即不使用缓存矩阵)，将图像顺时针旋转90度。 给定一个NxN的矩阵，和矩阵的阶数N,请返回旋转后的NxN矩阵,保证N小于等于500，图像元素小于等于256。 测试样例： [[1,2,3],[4,5,6],[7,8,9]],3 返回：[[7,4,1],[8,5
find(),findIndex()和indexOf()
绿色水杯的博客
06-06 638
1.find(): find() 方法返回通过测试（函数内判断）的数组的第一个元素的值。 find() 方法为数组中的每个元素都调用一次函数执行： 当数组中的元素在测试条件时返回 true 时, find() 返回符合条件的元素，之后的值不会再调用执行函数。 如果没有符合条件的元素返回 undefined 注意: find() 对于空数组，函数是不会执行的。 注意: find() 并没有改变数组的原始值。 我遇到的问题是：find()方法是直接return值，如果要在控制台输出，还需要通过赋给一个变量输出，
数组面试题解析：局部最小值与动态规划
- 对于数组面试题，不仅要掌握基本操作，还需要了解如何利用数组特性优化算法，如二分查找、动态规划等高级技巧。 - 了解数组与其他数据结构（如链表、堆、树等）的区别和联系，有助于在面试中灵活应对问题。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值