LeetCode数组算法题——题解与思路

1.寻找数组的中心索引

给定一个整数类型的数组 nums，请编写一个能够返回数组 “中心索引” 的方法。

我们是这样定义数组 中心索引 的：数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和。

如果数组不存在中心索引，那么我们应该返回 -1。如果数组有多个中心索引，那么我们应该返回最靠近左边的那一个。

题解思路：

主要是遍历数组，当前元素左侧索引元素的和与右侧比较。效率较高的判断方式是：先求得数组所有元素的和，再遍历数组时将元素累加，判断sumLeft(i左侧元素的和) ==sum(总和) -arr[i](当前元素的值) - sumLeft（右侧和，左侧右侧和相等）时，返回索引，并且此时所谓中心索引也是最靠近左侧的。

public int pivotIndex(int[] nums) {
        int sum = 0;
        int sumLeft = 0;
        for (int num : nums) {
            sum += num;
        }
        for (int i = 0; i < nums.length; i++) {
            if (sumLeft == sum - nums[i] - sumLeft) return i;
            sumLeft += nums[i];
        }
        return -1;
    }

2.搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

你可以假设数组中无重复元素。

题解思路：

采用二分法查找方式查找当前target值，如果找到taget元素值直接返回索引，如未找到直接返回left值。

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

3.合并区间

题解思路：

首先将二维数组以每个数组元素的[0]元素值从小到大排序，应用到Arrays.sort方法。创建集合容器用来存储合并后的结果，遍历二维数组，当集合为空或集合中数组元素[1]的值小于当前遍历的数组元素[0]值时，将该集合元素add到集合中，而当数组元素[1]大于遍历的当前数组元素[0]时合并数组（合并后数组元素[1]的值取两个数组元素中[1]的最大值｝）并add到集合中。

/*
    输入: intervals = [[1,3],[2,6],[8,10],[15,18]]
    输出: [[1,6],[8,10],[15,18]]
    解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

     */
public int[][] merge(int[][] intervals) {
        if (intervals.length == 0 || intervals.length == 1) return intervals;
        // 对二维数组以[0]元素值进行排序
        Arrays.sort(intervals, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[0] - o2[0];
            }
        });
        List<int[]> list = new LinkedList<>();
        for (int i = 0; i < intervals.length; i++) {
            int front = intervals[i][0], behind = intervals[i][1];
            // 集合为空，或前一个元素区间不包含当前元素的区间时，添加到集合中
            if (list.size() == 0 || list.get(list.size() - 1)[1] < front) {
                list.add(new int[]{front, behind});
            } else {
                list.get(list.size() - 1)[1] = Math.max(list.get(list.size() - 1)[1], behind);
            }
        }
        return list.toArray(new int[list.size()][]);
    }

4.旋转矩阵

给你一幅由 N × N 矩阵表示的图像，其中每个像素的大小为 4 字节。请你设计一种算法，将图像旋转 90 度。

不占用额外内存空间能否做到？

题解思路：

创建新二维数组容器int[][] result，嵌套遍历二维数组，遍历方式是从matrix[length-1~0]嵌套matrix[length-1~0][0~matrix[0].length-1]，同时赋值给result，最后替换matrix中的元素。

/*
        数组旋转90度
     */
    public static void rotate(int[][] matrix) {
        if (matrix.length == 0) return;
        int[][] result = new int[matrix[0].length][matrix.length];
        for (int i = 0; i < matrix[0].length; i++) {
            for (int j = 0; j < matrix.length; j++) {
                result[i][j] = matrix[matrix.length - 1 - j][i];
            }
        }
        for (int i = 0; i < matrix.length; i++) {
            matrix[i] = result[i];
        }
    }

5.零矩阵

 

编写一种算法，若M × N矩阵中某个元素为0，则将其所在的行与列清零。

题解思路：

本题需要注意的点是需要记录当前访问为0的元素，是否是因横纵某个值为0的元素改变而来。这时创建了一个boolean[][]二维数组来记录是否是被转换为0的元素在发现0值元素时遍历横纵向上的元素时，先判断其本来是否为0，如果值为0则不将对应坐标的boolean[][]改为true。

 public void setZeroes(int[][] matrix) {
        if (matrix.length == 0) return;
        // 遍历的同时判断该点是否由其他0元素改变而成
        boolean[][] isAccessed = new boolean[matrix.length][matrix[0].length];
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                if (!isAccessed[i][j] && matrix[i][j] == 0) {
                    // 水平方向元素变为0
                    for (int k = 0; k < matrix[i].length; k++) {
                        if (matrix[i][k] != 0) {
                            matrix[i][k] = 0;
                            isAccessed[i][k] = true;
                        }
                    }
                    // 竖直方向元素变为0
                    for (int k = 0; k < matrix.length; k++) {
                        if (matrix[k][j] != 0) {
                            matrix[k][j] = 0;
                            isAccessed[k][j] = true;
                        }
                    }
                }
            }
        }
    }

6.对角线遍历

给定一个含有 M x N 个元素的矩阵（M 行，N 列），请以对角线遍历的顺序返回这个矩阵中的所有元素，对角线遍历如下图所示。

题解思路：

matrix[r][c]顺序为：[0][0]、{[0][1]、[1][0]}、{[2][0]、[1][1]、[0][2]}、{[2][1]、[1][2]}、[2][2]，其中规律为r+c为偶数时是从下往上对角线遍历，奇数时为从上往下遍历。

    public int[] findDiagonalOrder(int[][] matrix) {
               if (matrix.length == 0) return new int[0];
        if (matrix.length == 1) return matrix[0];
        int row = matrix.length, col = matrix[0].length;
        int r = 0, c = 0;
        int[] result = new int[row * col];
        for (int i = 0; i < result.length; i++) {
            result[i] = matrix[r][c];
            if ((r + c) % 2 == 0) {// 偶数由下至上对角线遍历
                if (c == col - 1) {
                    r++;
                } else if (r == 0) {
                    c++;
                } else {
                    r--;
                    c++;
                }
            } else {// 奇数由上至下对角线遍历
                if (r == row - 1) {
                    c++;
                } else if (c == 0) {
                    r++;
                } else {
                    r++;
                    c--;
                }
            }
        }
        return result;
    }