数组题目总结 -- 花式遍历

已于 2023-05-25 15:07:02 修改
阅读量800 收藏
点赞数
分类专栏： 算法-系统整理 文章标签： leetcode 算法 职场和发展
于 2023-05-24 22:10:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39671159/article/details/130357126
版权

目录

一. 反转字符串中的单词

思路和代码：

I. 博主的做法

  • 先用trim()方法把字符串前后的多余空格全部去掉。
  • 再用replaceAll(“\\s+”, " ")；把多个空格替换成一个空格，\s代表空格，+代表多个。
  • 用split以空格为标志，切分字符串，放到字符串数组中。
  • 之后使用StringBuffer反向存储。
class Solution {
    public String reverseWords(String s) {
        s = s.trim().replaceAll("\\s+", " ");
        String[] temp = s.split(" ");
        StringBuffer stb = new StringBuffer();

        for(int i = temp.length-1; i > 0; i--){
            stb.append(temp[i] + " ");
        }
        stb.append(temp[0]);
        
        return stb.toString();
    }
}
  • 申请了额外的空间，原地反转，博主不会，，，
  • 时间复杂度：O(n)
  • 空间复杂度：O(n)

II. 东哥的做法

  • 先反转整个字符串。
  • 然后反转每一个单词。
    在这里插入图片描述
class Solution {
    public StringBuilder trimSpace(String s){
        int left = 0, right = s.length()-1;
		//去除开头和结尾的空格
        while(left <= right && s.charAt(left) == ' ')
            left++;
        while(left <= right && s.charAt(right) == ' ')
            right--;
            
		//去除字符串中间的空格
        StringBuilder stb1 = new StringBuilder();
        while(left <= right){

            if(s.charAt(left) != ' ')
                stb1.append(s.charAt(left));
            else if(stb1.charAt(stb1.length()-1) != ' ')
                stb1.append(s.charAt(left));
            
            left++;
        }
        return stb1;
    }
    
    //写的挺巧妙的反转函数，可以积累
    public void reverse(StringBuilder stb, int left, int right){
        while (left < right) {
            char temp = stb.charAt(left);
            stb.setCharAt(left++, stb.charAt(right));   
            stb.setCharAt(right--, temp);
        }

    }
    public void reverseWord(StringBuilder stb){
        int start = 0, end = 0;

        while(start < stb.length()){
            while(end < stb.length() && stb.charAt(end) != ' ')
                end++;
            
            reverse(stb, start, end-1);
            //寻找下一个单词
            start = end + 1;
            end++;
        } 

    }
    
    //总函数
    public String reverseWords(String s) {

        StringBuilder stb = trimSpace(s);
        
		//StringBuilder 不用再加返回值，直接就在原地操作了
        reverse(stb, 0, stb.length()-1);

        reverseWord(stb);

        return stb.toString();
    }
}
  • StringBuilder一定要定义在循环外面，循环里面的属于临时变量，外面的函数是调用不了的。
  • 如果是StringBuilder，就不用再有返回值，因为StringBuilder是可变的，而java中String是不可变的，需要额外申请空间进行操作。C++中，String是可变的，所以空间复杂度能降到O(1)，不需要额外申请空间。
  • 时间复杂度：O(n)
  • 空间复杂度：O(n)

III. 其他做法1

  • 去除开头和末尾的空格。
  • 运用正则表达式将字符串分成一个一个的单词（用一个或者多个空格当做分隔符），返回的数组转换成List。
  • 反转List，相当于将单词的顺序做一个反转。
  • 将空格加入到List当中。
class Solution {
    public String reverseWords(String s) {
        // 除去开头和末尾的空白字符
        s = s.trim();
        // 正则匹配连续的空白字符作为分隔符分割
        List<String> wordList = Arrays.asList(s.split("\\s+"));
        Collections.reverse(wordList);
        return String.join(" ", wordList);
    }
}
  • 时间复杂度：O(n)
  • 空间复杂度：O(n)
补充知识点：
  • 在Java 8及以上版本中，String.join()方法最后一个参数可以传入任何对象类型的可迭代集合.
  • 可迭代集合就是实现Iterable接口的集合，看下图：
    在这里插入图片描述
  • 需要注意的是：Java中数组也实现了Iterable接口，也就是，数组也可以通过join方法，返回字符串。

IV. 其他做法2

  • 去掉头尾两头的空格
  • 将字符串加入双端队列的头部或者直接加入栈中，如下图：
    在这里插入图片描述
class Solution {
    public String reverseWords(String s) {
        int left = 0, right = s.length()-1;
		//去掉前后两头的空格
        while(left <= right && s.charAt(left) == ' ')
            left++;
        while(left <= right && s.charAt(right) == ' ')
            right--;
        //使用双端队列存字符串，使用StringBuilder来存单词
        Deque<String> deque = new ArrayDeque<>();
        StringBuilder stb = new StringBuilder();

        while(left <= right){
        	//如果StringBuilder中不为空（单词存在），并且遇到下一个空格了，就从头部加入双端队列并清空StringBuilder
            if(stb.length() != 0 && s.charAt(left) == ' '){
                deque.offerFirst(stb.toString());
                stb.setLength(0);
            }
            else if(s.charAt(left) != ' ')
                stb.append(s.charAt(left));

            left++;
        }
        //记得加入最后一个单词，因为遇不到下一个空格了！！！   
        deque.offerFirst(stb.toString());
		
        return String.join(" ", deque);
    }
}
  • 时间复杂度：O(n)
  • 空间复杂度：O(n)

二. 旋转图像

思路和代码：

I. 博主的做法

  • 博主只能想到一圈一圈的进行迭代数组。。。太复杂了。

II. 东哥的做法

  • 先将矩阵沿对角线，做对称矩阵操作

在这里插入图片描述

  • 对矩阵的每一行进行反转
    在这里插入图片描述
    在这里插入图片描述
class Solution {
	//以对角线对称交换矩阵
    public void symmetry(int[][] matrix){
        for(int i = 0; i < matrix.length; i++)
            for(int j = 0; j < i; j++){
                int temp = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = temp;
            }
    }
    
    //将每一行进行反转
    public void reverse(int[] num){
        int left = 0, right = num.length-1;
        while(left <= right){
            int temp = num[left];
            num[left++] = num[right];
            num[right--] = temp;
        }

    }
    public void rotate(int[][] matrix) {
        symmetry(matrix);

        for(int[] n : matrix)
            reverse(n);
             
    }
}
  • 常规的思路就是去寻找原始坐标和旋转后坐标的映射规律，但我们是否可以让思维跳跃跳跃，尝试把矩阵进行反转、镜像对称等操作，可能会出现新的突破口。
  • 仔细想想，旋转二维矩阵的难点在于将「行」变成「列」，将「列」变成「行」，而只有按照对角线的对称操作是可以轻松完成这一点的，对称操作之后就很容易发现规律了。

三. 旋转图像（逆时针旋转90°）

  • 题目链接：无。
  • 函数名： public void rotate(int[][] matrix){ }

思路和代码：

I. 博主和东哥的做法

  • 和上一道题真的很像，就是沿着另一条对角线旋转，然后反转每一行。
    在这里插入图片描述
package 洛谷;

import java.util.Scanner;

public class Test {
	//沿逆对角线进行对称
    public static void romate(int[][] matrix){
        for(int i = 0; i < matrix.length; i++)
            for(int j = 0; j < matrix.length-i; j++){
                int temp = matrix[i][j];
                matrix[i][j] = matrix[matrix.length - 1 - j][matrix.length - 1 - i];
                matrix[matrix.length - 1 - j][matrix.length - 1 - i] = temp;
            }
    }

	//每行进行反转
    public static void reverse(int[] matrix){
        int left = 0, right = matrix.length-1;

        while(left <= right){
            int temp = matrix[left];
            matrix[left++] = matrix[right];
            matrix[right--] = temp;
        }
    }
    
    //主函数
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int[][] a = {{1,2,3,4}, {5,6,7,8}, {7,6,5,4},{4,1,2,3}};

        romate(a);

        for(int[] num : a)
            reverse(num);

        for(int i = 0; i < a.length; i++){
            for(int j = 0; j < a.length; j++)
                System.out.print(a[i][j] + " ");
            System.out.println();
        }

    }

}
  • 顺逆对角线对称的逻辑还是不太会，仍需加强

四. 矩阵的螺旋遍历

思路和代码：

I. 博主的做法

  • 设置4个边界，然后模拟顺序输出的样子，进行遍历
class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        int top = 0, left = 0, right = matrix[0].length-1, bottom = matrix.length-1;
        
        List<Integer> list = new ArrayList<>();

        while(left <= right && top <= bottom){
            for(int j = left; top <= bottom && j <= right; j++)
                list.add(matrix[top][j]);
            top++;

            for(int i = top; left <= right && i <= bottom; i++)
                list.add(matrix[i][right]);
            right--;

            for(int j = right; top <= bottom && j >= left; j--)
                list.add(matrix[bottom][j]);
            bottom--;

            for(int i = bottom; left <= right && i >= top; i--)
                list.add(matrix[i][left]);
            left++;
        }

        return list;
    }
}
  • 这一行写成：for(int j = left; left <= right && j <= right; j++)，这显然是错的，j <= right已经判断过了；其次，如果上下都是负的空间，左右又有什么意义呢？？
  • 还需要注意，螺旋输出，没拐个弯，对应的边界就要多走一格子。
  • 列的个数一定是matrix[0].length - 1，行的个数是matrix.length

II. 东哥的做法

  • 和博主想的一样，设置四个边界
List<Integer> spiralOrder(int[][] matrix) {
    int m = matrix.length, n = matrix[0].length;
    int upper_bound = 0, lower_bound = m - 1;
    int left_bound = 0, right_bound = n - 1;
    List<Integer> res = new LinkedList<>();
    // res.size() == m * n 则遍历完整个数组
    while (res.size() < m * n) {
        if (upper_bound <= lower_bound) {
            // 在顶部从左向右遍历
            for (int j = left_bound; j <= right_bound; j++) {
                res.add(matrix[upper_bound][j]);
            }
            // 上边界下移
            upper_bound++;
        }
        
        if (left_bound <= right_bound) {
            // 在右侧从上向下遍历
            for (int i = upper_bound; i <= lower_bound; i++) {
                res.add(matrix[i][right_bound]);
            }
            // 右边界左移
            right_bound--;
        }
        
        if (upper_bound <= lower_bound) {
            // 在底部从右向左遍历
            for (int j = right_bound; j >= left_bound; j--) {
                res.add(matrix[lower_bound][j]);
            }
            // 下边界上移
            lower_bound--;
        }
        
        if (left_bound <= right_bound) {
            // 在左侧从下向上遍历
            for (int i = lower_bound; i >= upper_bound; i--) {
                res.add(matrix[i][left_bound]);
            }
            // 左边界右移
            left_bound++;
        }
    }
    return res;
}
  • 思路是一样的，大家看着哪个顺眼参考哪个

五. 构建螺旋矩阵

思路和代码：

I. 博主的做法

  • 跟上个题几乎是一模一样，只是在每次循环当中进行的操作不同而已。
class Solution {
    public int[][] generateMatrix(int n) {
        int[][] matrix = new int[n][n];

        int top = 0, left = 0, right = n-1, bottom = n-1;
        int num = 1;

        while(top <= bottom && left <= right){
            for(int j = left; top <= bottom && j <= right; j++)
            	//这里不一样，下面同理
                matrix[top][j] = num++;
            top++;

            for(int i = top; left <= right && i <= bottom; i++)
                matrix[i][right] = num++;
            right--;

            for(int j = right; top <= bottom && j >= left; j--)
                matrix[bottom][j] = num++;
            bottom--;

            for(int i = bottom; left <= right && i >= top; i--)
                matrix[i][left] = num++;
            left++;
        }

        return matrix;
    }
}
  • 时间复杂度：O(n^2)，其中 n 是给定的正整数。矩阵的大小是 n×n，需要填入矩阵中的每个元素。
  • 空间复杂度：O(1)，除了返回的矩阵以外，空间复杂度是常数。

II. 东哥的做法

  • 和博主想的一样，设置四个边界
int[][] generateMatrix(int n) {
    int[][] matrix = new int[n][n];
    int upper_bound = 0, lower_bound = n - 1;
    int left_bound = 0, right_bound = n - 1;
    // 需要填入矩阵的数字
    int num = 1;
    
    while (num <= n * n) {
        if (upper_bound <= lower_bound) {
            // 在顶部从左向右遍历
            for (int j = left_bound; j <= right_bound; j++) {
                matrix[upper_bound][j] = num++;
            }
            // 上边界下移
            upper_bound++;
        }
        
        if (left_bound <= right_bound) {
            // 在右侧从上向下遍历
            for (int i = upper_bound; i <= lower_bound; i++) {
                matrix[i][right_bound] = num++;
            }
            // 右边界左移
            right_bound--;
        }
        
        if (upper_bound <= lower_bound) {
            // 在底部从右向左遍历
            for (int j = right_bound; j >= left_bound; j--) {
                matrix[lower_bound][j] = num++;
            }
            // 下边界上移
            lower_bound--;
        }
        
        if (left_bound <= right_bound) {
            // 在左侧从下向上遍历
            for (int i = lower_bound; i >= upper_bound; i--) {
                matrix[i][left_bound] = num++;
            }
            // 左边界右移
            left_bound++;
        }
    }
    return matrix;
}

参考：
https://labuladong.github.io/algo/di-yi-zhan-da78c/shou-ba-sh-48c1d/er-wei-shu-150fb/
https://leetcode.cn/problems/reverse-words-in-a-string/solution/fan-zhuan-zi-fu-chuan-li-de-dan-ci-by-leetcode-sol/

Marry Andy
关注
专栏目录
【算法思想·数组】二维数组的花式遍历
Captain823Jack的博客
08-17 480
本文参考labuladong算法小抄[
数组——二维数组的花式遍历技巧
c630843901的博客
05-24 484
文章目录顺/逆时针旋转矩阵矩阵的螺旋遍历 顺/逆时针旋转矩阵 对二维数组进行旋转是常见的笔试题，力扣第 48 题「 旋转图像」就是很经典的一道： 题目很好理解，就是让你将一个二维矩阵顺时针旋转 90 度，难点在于要「原地」修改 在讲巧妙解法之前，我们先看另一道谷歌曾经考过的算法题热热身： 给你一个包含若干单词和空格的字符串 s，请你写一个算法，原地反转所有单词的顺序。 比如说，给你输入这样一个字符串： s = "hello world labuladong" 你的算法需要原地反转这个字符串中的单词顺序：
二维数组的花式遍历技巧盘点
fdl123456的博客
12-13 2842
学算法认准labuladong后台回复进群进刷题读完本文，可以去力扣解决如下题目：48. 旋转图像（中等）54. 螺旋矩阵（中等）59. 螺旋矩阵 II（中等）有不少读者说，看过很多...
二维数组的花式遍历技巧
Alex抱着爆米花的博客
05-16 84
见过就会类型，纯技巧。
数组及字符串题目大杂烩
学习侠的博客
07-22 433
数组及字符串类型的题目花式很多，涉及到很多技巧，什么双指针、单调栈、分治、二分、动态规划。而且有的题目存在很多变体，比如字符串类题目中的回文串类的题目，看着大同小异，做起来往往容易犯难，因此有必要做个笔记记录一下解题思路。由于套路繁多，因此个人认为用“大杂烩”来代替“整理”作为标题更为贴切。当然，这是一项大工程，慢慢记录当做复习了！希望复习之后能在看到类似题目就映射到对应的技巧进而想到代码实现，哈哈，估计不可能。
数据结构与算法------数组
liaozhongmin_net
07-06 347
本文章将分为数据结构和算法两个部分，将会把数据结构与算法整体内容梳理一遍，题目来源leetcode，结合了许多人的不同解法，旨在让学习者通透同时也巩固自己的算法基础。
【Leetcode每日一刷】二维数组花式遍历：一、顺/逆时针旋转矩阵 ：48. 旋转图像、二、矩阵的螺旋遍历 |54. 螺旋矩阵
Yaoyao2024的博客
03-14 776
寻常的思路有以下两种：可能会误认为去模拟一下，一圈一圈的去遍历，然后进行旋转；又或者是想去找出当前坐标和旋转后像素对应坐标位置之间的关系，结果发现都想不出来很好的解决方法。它用了另外一种比较巧妙的方法，对于计算机比较好理解，但对于我们可能一下子想不到的方法去解决了。（对于这种题，只要有个印象，以后遇到类似题目就不会懵圈了。这题的意思很简单，就是让我们把矩阵。不可暴力模拟，先镜像，后水平翻转。❗❗核心思想/ 关键。
力扣刷题记录-数组相关问题
qq_41857397的博客
02-20 1229
汇总力扣中的数组类问题。
7.3.1 二叉树遍历的应用及LeetCode题目解析(1)
xutiantian1412的博客
05-05 665
这一节，我们看一下应用二叉树的遍历，可以解决哪些问题，如何应用这些原理刷题。花式遍历，加上我们接下来解析的题目，可以基本涵盖数据结构二叉树这部分的主要内容了。还是要对其中难点好好练习。 其实，在LeetCode中有几道题目就是遍历二叉树， 如 94 Binary Tree Inorder Traversal 144 Binary Tree Preorde...
LeetCode（268 & 287 & 448）：缺失数字 & 寻找重复数 & 找到所有数组中消失的数字（Java）
NJU_ChopinXBP的博客
08-15 390
2019.8.15 #程序员笔试必备# LeetCode 从零单刷个人笔记整理（持续更新） 这两道题题可以用各种方法花式做，比如排序、哈希、桶等等。 如果限定o(n)时间和o(1)空间的话，第一题可以有下面三种比较巧妙的方法： 交换 遍历元素并且循环将每一个元素放至其最终位置，最后再对所有元素检查，不匹配的元素为缺失元素。 异或 将所有数字和下标进行异或（补上末位），消除留下单一数字。 高斯求和...
2017年团体程序设计天梯赛 - 大区赛
idealism_xxm的专栏
03-25 7075
今天为了团体比赛，只得放弃个人的网易笔试... 3h内只AC了L1-1 ~ L1-8、L2-1 、 L2-3 ~ L2-4、L3-1（赛后已全部AC） L2-2（已AC） 和 L3-3（已AC）各得22分，L2-2先开始想用链表模拟，但觉得太麻烦，就改用数组模拟，非常好写，但是挂了第二个测试点；L3-3用dfs在一个测试点超时，看到空间很大，想到用map剪枝，最后没
【Numpy】高级索引：整数索引 | 算法面试：给定一个字符串，找出其中的最长回文子串。| 动态规划 | 中心扩展法
追光者♂：记录、分享、总结、提升，现象级专栏《Python从入门到人工智能》作者，无惧黑暗，坚信曙光
09-24 453
【Numpy】高级索引之整数索引。
《剑指offer》题解
祝如愿的博客
02-24 539
《剑指offer》题解
【科学刷题】彻底搞定二分算法所有题型
using namespace 数学工具构造器;
05-01 565
文章目录1. 花式二分查找1.1 有序数组的查找1.1.1 普通二分查找1.1.2 lower_bound1.1.3 upper_bound1.1.4 三种方法串讲1.1.4.11.2 旋转数组1.2.1 查找旋转数组的某个数1.2.1.1 无重复1.2.1.2 有重复1.2.2 查找旋转数组的最小值1.2.2.1 无重复1.2.2.2 有重复1.3 二维有序数组的查找1.3.1 行元素有序、列元素有序1.3.2 展开成一维有序1.4 查找缺失的数字2. 中位数2.1 两个正序数组的中位数2.2 数据流的中
[leetcode]113_路径总和II_输出所有路径
weixin_45653183的博客
09-24 415
leetcode 的 Python 代码——处理输入输出；仅记录便于以后自查自学使用
LeetCode 69. x 的平方根
野草说技术
09-27 335
注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5。解释：8 的算术平方根是 2.82842…, 由于返回类型是整数，小数部分将被舍去。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去。给你一个非负整数 x ，计算并返回 x 的 算术平方根。
LeetCode 滑动窗口 每个字符最多出现两次的最长子字符串
软小行的博客
09-23 344
LeetCode滑动窗口 每个字符最多出现两次的最长子字符串
LeetCode 53. 最大子数组和
最新发布
fujiang_xiao的博客
09-29 106
一是 nums[ i ] 作为前面的子数组的一部分，此时 dp [ i ] = dp[ i-1] + nums[ i ]；二是 nums[ i ] 作为一个新的子数组，此时 dp[ i ] = nums[ i ]。故递推公式为 dp[ i ] = Math.max(dp[ i-1] + nums[ i ], nums[ i ] )。贪心思路，取一个变量 cnt 记录当前子数组的和，如果 cnt < 0，这时就应该舍弃原来的子数组，将 cnt 置为0，重新记录新的子数组的和。是数组中的一个连续部分。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值