这篇博客总结了LeetCode中关于数组问题的解题思路，包括矩阵旋转、下一个排列、三数之和及两数之和的多种解决方案。涉及到的方法包括矩阵转置、双指针、冒泡排序、指针聚拢等技巧，旨在提升算法解决数组问题的能力。
数组问题
4, 48. 旋转图像
https://leetcode-cn.com/problems/rotate-image/
思路1: 先行转列，再进行行内前后替换即可
- 第一步：矩阵转置，也就是行转列
- 第二步：每一行进行对称对调
package com.shangguigu.dachang.algrithm.A01_arrays;
/**
* @author : 不二
* @date : 2021/12/21-下午4:03
* @desc : 旋转图像
* 参考：https://leetcode-cn.com/problems/rotate-image/
*
*
**/
public class A19_rotate {
public static void main(String[] args) {
int[][] image1 = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
int[][] image2 = {
{5, 1, 9, 11},
{2, 4, 8, 10},
{13, 3, 6, 7},
{15, 14, 12, 16}
};
rotate(image2);
printMetrix(image2);
}
public static void rotate(int[][] matrix) {
// 其实分两步：
// 第一步：矩阵转置，也就是行转列
// 第二步：每一行进行对称对调
for(int i=0;i<matrix.length;i++){
// 注意：这里是遍历每一行具体的内容哈，然后把对应数据的行列号给交换即可
for(int j=i+1;j<matrix[i].length;j++){
int temp = matrix[i][j];
matrix[i][j] = matrix[j][i];
matrix[j][i] = temp;
}
}
// 第二步：每一行进行对称对调
for(int i=0;i<matrix.length;i++){
// 1，这里直接循环一半交换
/*for (int j = 0; j < matrix[i].length/2; j++) {
System.out.println(i + "---" + j);
int tmp = matrix[i][j];
matrix[i][j] = matrix[i][matrix.length-1-j];
matrix[i][matrix.length-1-j] = tmp;
}*/
// 2，这里用双指针交换
int start = 0;
int end = matrix[i].length-start-1;
while(start < end) {
int temp = matrix[i][start];
matrix[i][start] = matrix[i][end];
matrix[i][end] = temp;
start++;
end--;
}
}
}
private static void printMetrix(int[][] maxtrix) {
for (int[] lines : maxtrix) {
for (int point : lines) {
System.out.print(point + "\t");
}
System.out.println();
}
}
}
思路2：把matrix分成四部分：左上，右上，右下，左下四部分，一次旋转即可
package com.shangguigu.dachang.algrithm.A01_arrays;
/**
* @author : 不二
* @date : 2021/12/21-下午4:03
* @desc : 旋转图像
* 参考：https://leetcode-cn.com/problems/rotate-image/
*
*
**/
public class A19_rotate {
public static void main(String[] args) {
int[][] image1 = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
int[][] image2 = {
{5, 1, 9, 11},
{2, 4, 8, 10},
{13, 3, 6, 7},
{15, 14, 12, 16}
};
rotateDirect(image2);
printMetrix(image2);
}
/**
* 直接旋转法优化版本：
* @param matrix
*/
public static void rotateOptimize(int[][] matrix) {
}
/**
* 直接旋转法：左上旋转到右上：原先列等于旋转后行，且：原先行 + 旋转后列 = 总行数/总列数
* 右上旋转到右下：原先列等于旋转后行，且：原先行 + 旋转后列 = 总行数/总列数
* 右下旋转到左下：原先列等于旋转后行，且：原先行 + 旋转后列 = 总行数/总列数
* 左下旋转到左上：原先列等于旋转后行，且：原先行 + 旋转后列 = 总行数/总列数
*
* 遍历规则是：行数： 0 - length/2 + length%2;
* 列数： 0 - length/2
*
*
* @param matrix
*/
public static void rotateDirect(int[][] matrix) {
// i是行，j是列， 这里遍历的应该是左上部分, 这里需要留意，如果是奇数，则需要计算一次
for (int i = 0; i < matrix.length / 2 + matrix.length % 2; i++) {
for (int j = 0; j < matrix.length / 2; j++) {
// 记录每一次遍历的这个位置对应的：左上，右上，右下，左下四部分的数据
int[] tmp = new int[4];
// 因为row, col是需要更改的，所以这里需要重新定义两个值
int row = i;
int col = j;
// 对于一个位置(i, j), 假设说对于3个长度的matrix，是(1, 0)这个位置，那么对应的四个部分分别是：(1,0), (0,1), (1,2), (2,1)
for (int k = 0; k < 4; k++) {
tmp[k] = matrix[row][col];
int x = row;
// 原先列 等于 旋转后行，也就是新的行 等于 旋转前 列
row = col;
col = matrix.length-1-x;
}
// 数据已经记录到tmp里面了, 然后写个循环把这四个数据从前到后替换一下即可
for (int k = 0; k < 4; k++) {
matrix[row][col] = tmp[(k + 3) % 4];
int x = row;
// 原先列 等于 旋转后行，也就是新的行 等于 旋转前 列
row = col;
col = matrix.length-1-x;
}
}
}
}
private static void printMetrix(int[][] maxtrix) {
for (int[] lines : maxtrix) {
for (int point : lines) {
System.out.print(point + "\t");
}
System.out.println();
}
}
}
思路2优化：不用tmp存储直接交换即可
package com.shangguigu.dachang.algrithm.A01_arrays;
/**
* @author : 不二
* @date : 2021/12/21-下午4:03
* @desc : 旋转图像
* 参考：https://leetcode-cn.com/problems/rotate-image/
*
*
**/
public class A19_rotate {
public static void main(String[] args) {
int[][] image1 = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
int[][] image2 = {
{5, 1, 9, 11},
{2, 4, 8, 10},
{13, 3, 6, 7},
{15, 14, 12, 16}
};
// rotateDirect(image2);
rotateOptimize(image2);
printMetrix(image2);
}
/**
* 直接旋转法优化版本：不需要tmp记录，而是直接交换即可
* @param matrix
*/
public static void rotateOptimize(int[][] matrix) {
// i是行，j是列， 这里遍历的应该是左上部分
for (int i = 0; i < matrix.length / 2 + matrix.length % 2; i++) {
for (int j = 0; j < matrix.length / 2; j++) {
int n = matrix.length;
int tmp = matrix[i][j];
matrix[i][j] = matrix[n-1-j][i];
matrix[n-1-j][i] = matrix[n-i-1][n-1-j];
matrix[n-1-i][n-1-j] = matrix[j][n-1-i];
matrix[j][n-1-i] = tmp;
/*// 记录每一次遍历的这个位置对应的：左上，右上，右下，左下四部分的数据
int[] tmp = new int[4];
// 因为row, col是需要更改的，所以这里需要重新定义两个值
int row = i;
int col = j;
// 对于一个位置(i, j), 假设说对于3个长度的matrix，是(1, 0)这个位置，那么对应的四个部分分别是：(1,0), (0,1), (1,2), (2,1)
for (int k = 0; k < 4; k++) {
tmp[k] = matrix[row][col];
int x = row;
// 原先列 等于 旋转后行，也就是新的行 等于 旋转前 列
row = col;
col = matrix.length-1-x;
}
// 数据已经记录到tmp里面了, 然后写个循环把这四个数据从前到后替换一下即可
for (int k = 0; k < 4; k++) {
matrix[row][col] = tmp[(k + 3) % 4];
int x = row;
// 原先列 等于 旋转后行，也就是新的行 等于 旋转前 列
row = col;
col = matrix.length-1-x;
}*/
}
}
}
/**
* 直接旋转法：左上旋转到右上：原先列等于旋转后行，且：原先行 + 旋转后列 = 总行数/总列数
* 右上旋转到右下：原先列等于旋转后行，且：原先行 + 旋转后列 = 总行数/总列数
* 右下旋转到左下：原先列等于旋转后行，且：原先行 + 旋转后列 = 总行数/总列数
* 左下旋转到左上：原先列等于旋转后行，且：原先行 + 旋转后列 = 总行数/总列数
*
* 遍历规则是：行数： 0 - length/2 + length%2;
* 列数： 0 - length/2
*
*
* @param matrix
*/
public static void rotateDirect(int[][] matrix) {
// i是行，j是列， 这里遍历的应该是左上部分
for (int i = 0; i < matrix.length / 2 + matrix.length % 2; i++) {
for (int j = 0; j < matrix.length / 2; j++) {
// 记录每一次遍历的这个位置对应的：左上，右上，右下，左下四部分的数据
int[] tmp = new int[4];
// 因为row, col是需要更改的，所以这里需要重新定义两个值
int row = i;
int col = j;
// 对于一个位置(i, j), 假设说对于3个长度的matrix，是(1, 0)这个位置，那么对应的四个部分分别是：(1,0), (0,1), (1,2), (2,1)
for (int k = 0; k < 4; k++) {
tmp[k] = matrix[row][col];
int x = row;
// 原先列 等于 旋转后行，也就是新的行 等于 旋转前 列
row = col;
col = matrix.length-1-x;
}
// 数据已经记录到tmp里面了, 然后写个循环把这四个数据从前到后替换一下即可
for (int k = 0; k < 4; k++) {
matrix[row][col] = tmp[(k + 3) % 4];
int x = row;
// 原先列 等于 旋转后行，也就是新的行 等于 旋转前 列
row = col;
col = matrix.length-1-x;
}
}
}
}
private static void printMetrix(int[][] maxtrix) {
for (int[] lines : maxtrix) {
for (int point : lines) {
System.out.print(point + "\t");
}
System.out.println();
}
}
}
3, 31.下一个排列
https://leetcode-cn.com/problems/next-permutation/
-
如下图所示：
-
1, 从右往左，找到第一个下降的点p1,
-
2, 然后从p1右侧：从左往右，找到第一个等于或着小于p1的点p2。然后p2点往前推一个点：p3就是比p1次大的数字。
-
3, 把p1/p3进行交换后，然后把p1右侧的所有数字：逆序调整一下即可(从右往左看，是升序，我们逆序为降序即可)
代码解法1：内部使用双指针进行逆转
- 这里代码效率要高于解法2
package com.shangguigu.dachang.algrithm.A01_arrays;
import java.util.ArrayList;
import java.util.Arrays;
/**
* @author : 不二
* @date : 2021/12/21-下午2:47
* @desc :
*
* 31. 下一个排列
* 实现获取 下一个排列 的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列（即，组合出下一个更大的整数）。
*
* 如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
*
* 必须 原地 修改，只允许使用额外常数空间。
*
*
*
* 示例 1：
*
* 输入：nums = [1,2,3]
* 输出：[1,3,2]
* 示例 2：
*
* 输入：nums = [3,2,1]
* 输出：[1,2,3]
* 示例 3：
*
* 输入：nums = [1,1,5]
* 输出：[1,5,1]
* 示例 4：
*
* 输入：nums = [1]
* 输出：[1]
*
*
* 提示：
*
* 1 <= nums.length <= 100
* 0 <= nums[i] <= 100
*
**/
public class A17_nextPermutation {
public static void main(String[] args) {
int[] nums = {1, 2, 3};
nextPermutation(nums);
for (int i = 0; i < nums.length; i++) {
System.out.println("结果是：" + nums[i]);
}
}
public static void nextPermutation(int[] nums) {
// 从后往前， 找到第一个降低的数字， 然后把该数字：与后面比该数次大的数字交换，最后把该数字后面的所有数字从小到大排列
// 如果从后往前找不到降低的数字，说明是一直升高的。那么这个数字就是不存在下一个更大的排列，则反转该序列即可。
// 如果只有一个数，那就没有调整的必要
if(nums.length < 2){
return;
}
int i = nums.length-2;
while (i >= 0 && nums[i] >= nums[i+1]) {
i--;
}
if(i==-1){
// 说明已经是最大的排列了，没有更大的排序了
// 这里sort的时间复杂度是：nlogn，但是因为其实已经是有序的了，只是需要反转一下，
// 所以可以直接双指针调整，降低时间复杂度为：n
// Arrays.sort(nums);
int start = 0;
int end = nums.length-1;
while(start < end){
int temp1 = nums[start];
nums[start] = nums[end];
nums[end] = temp1;
start++;
end--;
}
return;
}
// System.out.println("---" + i);
// 走到这里，说明找到了降序的了
// 需要把num[i]替换成i后面比num[i]次大的数字
int numToReplace = nums[i];
// 后面的数字都是降序的，所以从左到右找到第一个小于等于的数字，然后该数字左边的那个数字肯定是比num[i]次大的数字了
int j = i+1;
while (j < nums.length && nums[j] > numToReplace) {
j++;
}
// 到这里说明已经找到了(如果中间没有break，最后的值是nums.length，会取出最后一个值，也不会有啥问题)
// int biggerALitter = nums[j-1];
// 这里替换掉
int temp = nums[i];
nums[i] = nums[j-1];
nums[j-1] = temp;
// 然后就是：把i后面的数字从小到大排列
// i+1 ---> nums.length
// 因为后面的数字都是有顺序的，只需要revert一下。
int start = i+1;
int end = nums.length-1;
while(start < end){
int temp1 = nums[start];
nums[start] = nums[end];
nums[end] = temp1;
start++;
end--;
}
}
}
代码解法2: 内部排序使用冒泡，先排序后交换拐点值
package com.shangguigu.dachang.algrithm.A01_arrays;
import java.util.Arrays;
/**
* @author : 不二
* @date : 2022/4/4-下午7:05
* @desc :
**/
public class A17_nextPermutation_by_bool {
public static void main(String[] args) {
// int[] nums = {4, 3, 2, 1};
// int[] nums = {1, 1, 3, 4, 2, 0, -1};
int[] nums = {1, 3, 2};
nextPermutation(nums);
System.out.println("结果是：" + Arrays.toString(nums));
}
public static void nextPermutation(int[] nums) {
// 1, 从右往左找到第一个下降的点位置p1
int p1 = -1;
for (int i = nums.length - 1; i > 0; i--) {
System.out.println(i);
if (nums[i - 1] < nums[i]) {
p1 = i-1;
break;
}
}
// 2, 如果没有下降点，说明是逆序排列组合，直接反转成正序即可
if (p1 == -1) {
for (int i = 0; i < nums.length/2; i++) {
int tmp = nums[i];
nums[i] = nums[nums.length-i-1];
nums[nums.length-i-1] = tmp;
}
return;
}
// 3, 如果有下降点
// System.out.println("第一个下降到数字是：" + p1 + "---" + nums[p1]);
// 3.1, 然后对p1后的数据进行正序排序
for (int i = p1 + 1; i < nums.length; i++) {
// System.out.println("00000");
for (int j = p1 + 1; j < nums.length - i -1 + p1 + 1; j++) {
if(nums[j] > nums[j+1]){
int tmp = nums[j];
nums[j] = nums[j+1];
nums[j+1] = tmp;
}
// System.out.println(Arrays.toString(nums) + "---" + j);
}
}
// 3.2, 然后找到p1后第一个大于p1点的数据，替换即可
for (int i = p1 + 1; i < nums.length; i++) {
if(nums[i] > nums[p1]){
int tmp = nums[i];
nums[i] = nums[p1];
nums[p1] = tmp;
// 第一次替换直接退出即可
break;
}
}
}
}
2, 15. 三数之和：
https://leetcode-cn.com/problems/3sum/
思路1, 暴力解法，只不过要进行排序去重
- 这里效率非常低
/**
* 这里不对的， 这个是暴力解法
* 不过不好去重：原先没有去重，后来采用：如果三个月满足要求，那么先把这三个数字冒泡排序，然后再进行拼接，组成map，如果之前没有该key，则说明不重复
* 方法虽然可行，不过效率太低，提交到leetcode上会超时
* @param nums
* @return
*/
public static List<List<Integer>> threeSum111(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
if(nums.length < 3) {
return result;
}
HashMap<String, Integer> theMap = new HashMap<>();
for(int i=0;i<nums.length-2;i++){
for(int j=i+1;j<nums.length-1;j++){
for(int k=j+1;k<nums.length;k++){
if(nums[i] + nums[j] + nums[k] == 0){
int[] theArr = new int[]{nums[i], nums[j], nums[k]};
// 先对数据进行排序
// bubbuleSort(theArr);
int size = theArr.length;
// 遍历到倒数第二个数字即可
for (int i1=0; i1 < size-1;i1++){
for (int j1 = 0; j1 < size-i1-1; j1++) {
// System.out.println(j + "###" + arr[j] + "###" + arr[j+1]);
if (theArr[j1] > theArr[j1+1]) {
int temp = theArr[j1];
theArr[j1] = theArr[j1+1];
theArr[j1+1] = temp;
}
}
}
String key = theArr[0] + "-" + theArr[1] + "-" + theArr[2];
if(!theMap.containsKey(key)) {
// 说明不是重复的
theMap.put(key, 1);
ArrayList<Integer> integers = new ArrayList<>();
integers.add(nums[i]);
integers.add(nums[j]);
integers.add(nums[k]);
result.add(integers);
}
// result.add(theResult);
}
}
}
}
return result;
}
思路2, 在暴力解法基础上优化：先遍历第一遍，然后求出剩余两数之和，然后按照两数之和的解法对剩下的数字进行求解，不过依然要去重
- 效率依然不高
/**
* 本来的思路是：遍历第一遍：用 0-遍历数字， 就是target，这个target就是两数之和。
* 但是这里就无法去重了：也是使用先排序，后转换为串然后判断去重。
* 不过效率依然不行，时间还是过长
* 怎么去重判断呢
* @param nums
* @return
*/
public static List<List<Integer>> threeSum_not_right(int[] nums) {
ArrayList<List<Integer>> result = new ArrayList<>();
// 这个用来记录去除第一个数，另外两数之和的(value, index)
// 如果value已经存在， 则
// 这个用来判断拿到到三个数字是否重复
HashMap<String, Integer> theMap = new HashMap<>();
// 第一遍先求出剩余两个数的和，
// 就变成了两数之和的解题思路了
for(int i=0;i<nums.length-1;i++){
int target = -nums[i];
// 需要在内部创建map，每个循环都是一个新的map
HashMap<Integer, Integer> map = new HashMap<>();
for(int j=i+1;j<nums.length;j++){
if(map.containsKey(target-nums[j])){
System.out.println(i + "##" + j + "##");
// 组成数组，先排序，
int[] theArr = new int[]{nums[i], target-nums[j], nums[j]};
int size = theArr.length;
// 遍历到倒数第二个数字即可
for (int i1=0; i1 < size-1;i1++){
for (int j1 = 0; j1 < size-i1-1; j1++) {
// System.out.println(j + "###" + arr[j] + "###" + arr[j+1]);
if (theArr[j1] > theArr[j1+1]) {
int temp = theArr[j1];
theArr[j1] = theArr[j1+1];
theArr[j1+1] = temp;
}
}
}
// 然后组合成串，判断去重
String key = theArr[0] + "-" + theArr[1] + "-" + theArr[2];
if(!theMap.containsKey(key)) {
// 说明不是重复的
theMap.put(key, 1);
ArrayList<Integer> integers = new ArrayList<>();
integers.add(theArr[0]);
integers.add(theArr[1]);
integers.add(theArr[2]);
result.add(integers);
}
}
map.put(nums[j], j);
}
}
return result;
}
思路3, 双指针法
- 这里涉及到的指针式是左右指针，开头一个，结尾一个，往中间聚拢。除此之外还有另外一个指针：快慢指针，后续可能会涉及到。
- 排序
- 先判断，如果最大值小于0，则无解，直接退出即可
- 第一轮遍历，遍历的值即为最小值min = num[i]
- 如果min最小值大于0，则直接退出即可
- 如果遍历过程前后两数字相同，可直接跳过
- 然后设定两个指针：leftPointer=i+1，对应mid = nums[leftPointer]， rightPointer为nums.length-1，对应max= nums[rightPointer]。
- while (leftPointer < rightPointer)保持循环
- if (min + mid + max == 0)则找到一组答案，加入结果中。并进行：leftPointer++;rightPointer–; 如果遇到相同元素，则跳过
- if (min + mid + max > 0)，说明最大值太大了，rightPointer–;
- if (min + mid + max < 0)，说明最小值太小了，leftPointer++;
public static List<List<Integer>> threeSum_TwoPointer(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
// 1, 先排序
Arrays.sort(nums);
System.out.println(Arrays.toString(nums));
// 2， 先判断，如果最大值小于0，则无解，直接退出即可
if(nums.length == 0 || nums[0] > 0 || nums[nums.length-1] < 0) {
return result;
}
// 3，第一轮遍历，遍历的值即为最小值min = num[i]
int min;
for (int i = 0; i < nums.length; i++) {
min = nums[i];
// 4， 如果min最小值大于0，则直接退出即可
if(min > 0) {
break;
}
// 5, 如果遍历过程前后两数字相同，可直接跳过
if(i>0 && nums[i] == nums[i-1]){
continue;
}
// 6, 然后设定两个指针：leftPointer=i+1，对应mid = nums[leftPointer]，
// rightPointer为nums.length-1，对应max= nums[rightPointer]。
int leftPointer = i+1;
int rightPointer = nums.length-1;
// 7, while (leftPointer < rightPointer)保持循环
while (leftPointer < rightPointer) {
int mid = nums[leftPointer];
int max = nums[rightPointer];
// System.out.println("第一个数：" + i + "第二个数：" + leftPointer + "第三个数：" + rightPointer);
// System.out.println("------------------");
if (min + mid + max == 0) {
// 8, if (min + mid + max == 0) 则找到一组答案，加入结果中。
// 并进行：leftPointer++;rightPointer--; 如果遇到相同元素，则跳过
result.add(Arrays.asList(min, mid, max));
leftPointer++;
rightPointer--;
// 如果元素相同，需要跳过，要不然数据会重复
// leftPointer < rightPointer 需要加上
while(leftPointer < rightPointer && nums[leftPointer-1] == nums[leftPointer]){
leftPointer++;
}
while (leftPointer < rightPointer && nums[rightPointer] == nums[rightPointer+1]) {
rightPointer--;
}
} else if(min + mid + max > 0){
// 9, 说明最大值太大了
rightPointer--;
} else if(min + mid + max < 0){
// 10, 说明最小值太小了
leftPointer++;
}
}
}
return result;
}
1, 1. 两数之和：
https://leetcode-cn.com/problems/two-sum/submissions/
思路1: 两次遍历，直接解答
/**
* 暴力解法： 双重for循环
* @param nums
* @param target
* @return
*/
public static int[] twoSumByVioLence(int[] nums, int target) {
for(int i=0; i<nums.length-1;i++){
for(int j=i+1;j<nums.length;j++){
if(nums[i]+nums[j] == target){
return new int[]{i, j};
}
}
}
throw new IllegalArgumentException("无符合要求数据");
}
思路2: 把全部数据存入到map中，可以直接查找判断
/**
* 这里是先把数据全部数据存入到map中。不过更有效的是：遍历的时候， 查map，如果没有， 把当前被遍历的加入。
* @param nums
* @param target
* @return
*/
public static int[] twoSumByHashmap(int[] nums, int target) {
HashMap<Integer, Integer> map = new HashMap<>();
for (int i = 1; i < nums.length; i++) {
map.put(nums[i], i);
}
for (int i = 0; i < nums.length; i++) {
if (map.containsKey(target - nums[i]) && i != map.get(target - nums[i])) {
// 说明剩下一个值已经找到
return new int[]{i, map.get(target - nums[i])};
}
}
throw new IllegalArgumentException("无符合要求数据");
}
思路3: 思路2可以优化，遍历的时候，查map，如果没有，把当前被遍历的加入。
/**
* 先遍历，如果map中没有， 把当前数据放入map，可以提高效率
* @param nums
* @param target
* @return
*/
public static int[] twoSumByHashmapV1(int[] nums, int target) {
HashMap<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
if (map.containsKey(target - nums[i])) {
// 说明剩下一个值已经找到
return new int[]{i, map.get(target - nums[i])};
}
map.put(nums[i], i);
}
throw new IllegalArgumentException("无符合要求数据");
}
扫一扫
258
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
