java数据结构刷题二期

已于 2023-04-21 13:08:19 修改
阅读量566 收藏 1
点赞数
分类专栏： java数据结构练习 文章标签： 数据结构 算法 matlab
于 2023-04-18 22:22:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ITjingxinbao/article/details/130232629
版权

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

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

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

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

示例 1：


输入：mat = [[1,2],[3,4]], r = 1, c = 4
输出：[[1,2,3,4]]
示例 2：


输入：mat = [[1,2],[3,4]], r = 2, c = 4
输出：[[1,2],[3,4]]

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

class Solution {
    public int[][] matrixReshape(int[][] mat, int r, int c) {
        //给定参数不合理
        if(r * c != mat.length * mat[0].length){
            return mat;
        }
        //参数合理
        int[][] arr = new int[r][c];
        int n = mat[0].length;//原数组的列数
        //将二维数组映射到一维数组中
        //映射行：元素位数 / 数组列数
        //映射列：元素位数 % 数组列数
        for (int i = 0; i < r * c; i++) {
            arr[i / c][i % c] = mat[i / n][i % n];
        }
        return arr;
    }
}

作者：frosty-7ichtermanwgr
链接：https://leetcode.cn/problems/reshape-the-matrix/solution/566-zhong-su-ju-zhen-by-frosty-7ichterma-fjcl/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
解法二
class Solution {
    public int[][] matrixReshape(int[][] mat, int r, int c) {
        int m = mat.length, n = mat[0].length, x = 0;
        if(m * n != r * c) return mat;
        HashMap<Integer, Integer> hash = new HashMap<Integer, Integer>();
        for(int i = 0; i < m; ++i){
            for(int j = 0; j < n; ++j){
                hash.put(x++, mat[i][j]);
            }
        }
        int[][] newMat = new int[r][c];
        for(int i = 0; i < r; ++i){
            for(int j = 0; j < c; ++j){
                newMat[i][j] = hash.get(i*c + j);
            }
        }


作者：azure-ku
链接：https://leetcode.cn/problems/reshape-the-matrix/solution/hashmapshi-xian-by-azure-ku-9tq9/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

题目二

给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。

在「杨辉三角」中，每个数是它左上方和右上方的数的和。

示例 1:

输入: numRows = 5
输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]

示例 2:

输入: numRows = 1
输出: [[1]]

class Solution {
    public static List<List<Integer>> generate(int numRows) {
        ArrayList<List<Integer>> lists = new ArrayList<>();
        ArrayList<Integer> integers1 = new ArrayList<>();
        //定义一个临时存储上一行结果的集合
        ArrayList<Integer> temp = integers1;
        for (int i = 1; i <= numRows; i++) {
            temp = getRow(temp, i);
            lists.add(temp);
        }
        return lists;
    }
    //该方法通过上一行的数据计算出本行的数据
    public static ArrayList<Integer> getRow(List<Integer> list, int n) {
        ArrayList<Integer> integers = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            if (i == 0 || i == n - 1) {
                integers.add(1);
            } else {
                integers.add(list.get(i - 1) + list.get(i));
            }
        }
        return integers;
    }
}

作者：tj-xiong
链接：https://leetcode.cn/problems/pascals-triangle/solution/118yang-hui-san-jiao-by-tj-xiong-0pje/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

题目3

请你判断一个 9 x 9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。

  1. 数字 1-9 在每一行只能出现一次。
  2. 数字 1-9 在每一列只能出现一次。
  3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

注意：

  • 一个有效的数独（部分已被填充）不一定是可解的。
  • 只需要根据以上规则，验证已经填入的数字是否有效即可。
  • 空白格用 '.' 表示。

示例 1：

输入：board = 
[["5","3",".",".","7",".",".",".","."]
,["6",".",".","1","9","5",".",".","."]
,[".","9","8",".",".",".",".","6","."]
,["8",".",".",".","6",".",".",".","3"]
,["4",".",".","8",".","3",".",".","1"]
,["7",".",".",".","2",".",".",".","6"]
,[".","6",".",".",".",".","2","8","."]
,[".",".",".","4","1","9",".",".","5"]
,[".",".",".",".","8",".",".","7","9"]]
输出：true

示例 2：

输入：board = 
[["8","3",".",".","7",".",".",".","."]
,["6",".",".","1","9","5",".",".","."]
,[".","9","8",".",".",".",".","6","."]
,["8",".",".",".","6",".",".",".","3"]
,["4",".",".","8",".","3",".",".","1"]
,["7",".",".",".","2",".",".",".","6"]
,[".","6",".",".",".",".","2","8","."]
,[".",".",".","4","1","9",".",".","5"]
,[".",".",".",".","8",".",".","7","9"]]
输出：false
解释：除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。 但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。
class Solution {
    public boolean isValidSudoku(char[][] board) {
        int[][] rows = new int[9][9];
        int[][] columns = new int[9][9];
        int[][][] subboxes = new int[3][3][9];
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                char c = board[i][j];
                if (c != '.') {
                    int index = c - '0' - 1;
                    rows[i][index]++;
                    columns[j][index]++;
                    subboxes[i / 3][j / 3][index]++;
                    if (rows[i][index] > 1 || columns[j][index] > 1 || subboxes[i / 3][j / 3][index] > 1) {
                        return false;
                    }
                }
            }
        }
        return true;
    }
}

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/valid-sudoku/solution/you-xiao-de-shu-du-by-leetcode-solution-50m6/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
解法二
class Solution {
    public boolean isValidSudoku(char[][] board) {
        //遍历行
        for (int i = 0; i < 9; i++) {
            //存储第i行的数
            Set<Character> row = new HashSet<>();
            //存储第j列的数字
            Set<Character> column = new HashSet<>();
            //3*3九宫格
            Set<Character> square = new HashSet<>();

            //遍历列
            for (int j = 0; j < 9; j++) {
                //1、判断每行的合理性
                char chRow = board[i][j];//第i行
                //不是空白格，即是数字，判断数字合理性
                if(chRow != '.'){
                    if(row.contains(chRow)){
                        //第i行出现相同数字
                        return false;
                    }else{
                        //未出现该数字将其添加至集合中
                        row.add(chRow);
                    }
                }

                //2、判断每列的合理性
                char chColumn = board[j][i];//第i列
                //判断第i列的合理性
                if(chColumn != '.'){
                    if(column.contains(chColumn)){
                        //第i列出现相同数字
                        return false;
                    }else{
                        //未出现该数字将其添加至集合中
                        column.add(chColumn);
                    }
                }

                //3、判断3*3九宫格的合理性
                char chSquare =  board[i/3*3 + j/3][i%3*3 + j%3];
                if(chSquare != '.'){
                    if(square.contains(chSquare)){
                        return false;
                    }else{
                        //未出现该数字将其添加至集合中
                        square.add(chSquare);
                    }
                }
            }
        }
        return true;
    }
}

作者：frosty-7ichtermanwgr
链接：https://leetcode.cn/problems/valid-sudoku/solution/36-you-xiao-de-shu-du-yi-ci-bian-li-by-f-0fxv/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 题目4

给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法。

示例 1：


输入：matrix = [[1,1,1],[1,0,1],[1,1,1]]
输出：[[1,0,1],[0,0,0],[1,0,1]]
示例 2：


输入：matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
输出：[[0,0,0,0],[0,4,5,0],[0,3,1,0]]

class Solution {
    public void setZeroes(int[][] matrix) {
        int m = matrix.length, n = matrix[0].length;
        boolean[] row = new boolean[m];
        boolean[] col = new boolean[n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (matrix[i][j] == 0) {
                    row[i] = col[j] = true;
                }
            }
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (row[i] || col[j]) {
                    matrix[i][j] = 0;
                }
            }
        }
    }
}

387. 字符串中的第一个唯一字符

给定一个字符串 s ，找到 它的第一个不重复的字符，并返回它的索引 。如果不存在，则返回 -1 。

示例 1：

输入: s = "leetcode"
输出: 0

示例 2:

输入: s = "loveleetcode"
输出: 2

示例 3:

输入: s = "aabb"
输出: -1

class Solution {
    public int firstUniqChar(String s) {
        Map<Character, Integer> frequency = new HashMap<Character, Integer>();
        for (int i = 0; i < s.length(); ++i) {
            char ch = s.charAt(i);
            frequency.put(ch, frequency.getOrDefault(ch, 0) + 1);
        }
        for (int i = 0; i < s.length(); ++i) {
            if (frequency.get(s.charAt(i)) == 1) {
                return i;
            }
        }
        return -1;
    }
}

解法二
class Solution {
    public int firstUniqChar(String s) {
        int[] arr = new int[26];//记录字符个数
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            arr[ch - 'a']++;//统计个数
        }
        //按照字符串遍历
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if(arr[ch - 'a'] == 1){
                return i;
            }
        }
        //未找到
        return -1;
    }
}

383. 赎金信

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

示例 1：

输入：ransomNote = "a", magazine = "b"
输出：false

示例 2：

输入：ransomNote = "aa", magazine = "ab"
输出：false

示例 3：

输入：ransomNote = "aa", magazine = "aab"
输出：true

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        if (ransomNote.length() > magazine.length()) {
            return false;
        }
        int[] cnt = new int[26];
        for (char c : magazine.toCharArray()) {
            cnt[c - 'a']++;
        }
        for (char c : ransomNote.toCharArray()) {
            cnt[c - 'a']--;
            if(cnt[c - 'a'] < 0) {
                return false;
            }
        }
        return true;
    }
}

解法二
class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        Map<Character,Integer> map = new HashMap<>();//key-字母   value-个数
        //将magazine中元素存入map中
        for (int i = 0; i < magazine.length(); i++) {
            char ch = magazine.charAt(i);
            //map中存在ch则将他的value值加一，没有ch则value值默认为0再加一
            map.put(ch,map.getOrDefault(ch,0) + 1);
        }
        //将ransomNote中的字母从map中移除，若不存在则返回false
        for (int i = 0; i < ransomNote.length(); i++) {
            char ch = ransomNote.charAt(i);
            //map中存在字母ch并且个数大于0
            if(map.containsKey(ch) && map.get(ch) > 0){
                //存在则value值减一
                map.put(ch,map.get(ch) - 1);
            }else{
                //不存在
                return false;
            }
        }
        return true;
    }
}

. 有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false
class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        char[] str1 = s.toCharArray();
        char[] str2 = t.toCharArray();
        Arrays.sort(str1);
        Arrays.sort(str2);
        return Arrays.equals(str1, str2);
    }
}
解法二
class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        int[] table = new int[26];
        for (int i = 0; i < s.length(); i++) {
            table[s.charAt(i) - 'a']++;
        }
        for (int i = 0; i < t.length(); i++) {
            table[t.charAt(i) - 'a']--;
            if (table[t.charAt(i) - 'a'] < 0) {
                return false;
            }
        }
        return true;
    }
}

ITjingxinbao
关注
专栏目录
华为OD机试真题目录汇总（C语言、C++、Java、Python、JS五种语言解法）2024 B+C+D卷
KJ.JK
08-12 8万+
本文是2024华为OD机试真题(C C++ Java Py JS) B卷专栏的目录贴（定期更新华为OD各个时间阶段的机试真题，每日定时更新，本专栏每篇的文章都会将使用C语言、C++、Python、Java、JS五种语言进行更新解答，包含真题，思路分析，代码参考，每个题目的思路分析都非常详细，超过百字欢迎大家订阅学习，代码可以直接运行使用，限时优惠，持续更新）华为OD是Outsourcing Dispacth模式，是华为和外企德科联合招聘的简称。目前华为大多数是OD招聘。
【力扣刷题笔记第三期】Python 数据结构与算法
许虹蕾的博客
05-21 1190
简单题汇总
刷题集训第二期代码.zip
04-06
在压缩包中的文件名“刷题集训第二期代码”，没有具体的文件类型信息，但通常这类集训的代码文件可能是`.cpp`（C++）、`.java`（Java）、`.py`（Python）或其他编程语言的源代码文件。每份代码文件通常会包含一个...
Java基础刷题
PPDY93的博客
03-04 4566
文章目录 下面哪些是合法的变量名？（BCDE） A. 2variable B. variable2 C. _whatavariable D. _3_ E. $anothervar F. #myvar G. $_￥ A. 不能以数字开头 F. 不能以#开头 G. 不能以中文￥命名 标识符的规范：26个字母，数字，_，$,数字不要开头 有一段java应用程序，类名是A1，那么保存它的源文件名可以是（AD） A) A1.java B) a1.class C) a1 D) D.java E) 都对
【java】leetcode刷题记录+简单思路（hot100+剑指offer 简单\中等难度）
昂萨哈凯尔可真难记啊
08-14 1243
避免重复刷题每次都两眼一抹黑咩都不记得，简单记一下思路。 1. 两数之和（简单） 2. 两数相加（中等） 3. 无重复字符的最长子串（中等） 4. 寻找两个正序数组的中位数（困难） 5. 最长回文子串（中等） 10. 正则表达式匹配（困难） 11. 盛最多水的容器（中等） 15. 三数之和（中等） 17. 电话号码的字母组合（中等） 19. 删除链表的倒数第 N 个结点（中等） ...
数据结构之线性表（python）
huaz_md的博客
09-16 516
线性表零个或多个数据元素的有限序列在逻辑结构上具有线性关系。将具有“一对一”关系的数据“线性”地存储到物理空间中，这种存储结构就称为线性存储结构（简称线性表线性表元素的个数nn>=0）定义为线性表的长度，当n=0时，称为空表。在较复杂的线性表中，一个数据元素可以有若干个数据项组成。线性表又可以分为顺序表顺序存储结构）和链表链式存储结构。
从零开始学数据结构系列之第六章《希尔排序》
铁匠匠匠的博客
09-14 862
​ 希尔排序是对插入排序的优化，基本思路是先选定一个整数作为增量，把待排序文件中的所有数据分组，以每个距离的等差数列为一组，对每一组进行排序，然后将增量缩小，继续分组排序，重复上述动作，直到增量缩小为1时，排序完正好有序。​ 我们发现，当被排序的对象越接近有序时，插入排序的效率越高，那我们是否有办法将数组变成接近有序后再用插入排序，此时希尔大佬就发现了这个排序算法，并命名为希尔排序。逆序有序的数组排序时，时间复杂度为O ( n 2 ) O(n^2)O(n 2)，此时效率最低。如果是最开始的分组方法的话。
LeetCode力扣二叉树算法训练
你白勺男孩TT的博客
09-13 326
经典问题，根据前序遍历和中序遍历还原一棵二叉树，虽然这个函数的参数比较多，但是它主要是控制数组的索引而已，注意到build的位置，本质上该算法也就是一个前序遍历，因为它在前序遍历的位置上加了一个代码逻辑。注意递归函数的位置，这就是后序遍历嘛，无非就是把traverse函数名字改成了oneSideMax了。中序遍历对于一棵二叉搜索树意味着什么？
排序算法-交换排序
weixin_74312694的博客
09-16 807
1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序2. 时间复杂度：O(N*logN)如果还想了解更多排序欢迎大家前往我的主页。
Java-数据结构-二叉树-基础 (oﾟ▽ﾟ)o
2303_80388948的博客
09-12 910
OK，到这里呢，我们的二叉树基础就到这里就结束了，我们接下来看看关于二叉树的相关的习题，并且在题中我们会看见我们 二叉树的创建方法。让我们期待下次的博客吧！！！拜拜啦~~~
MATLAB系列03：分支语句和编程设计
lbm666666的博客
09-16 807
所谓的自顶向下的编程方法，本质上就是编写程序的视角从整体的宏观性逐层进入具体的微观性的一种编程思想。我们编写程序时一开始不用思考得事无巨细，把所有细节都想清楚；也不要面条式的想到哪里写到哪里。而应该是自顶向下的，从一个大的粗的核心的任务开始，逐级细分，最后再完成最底层的具体实现。清晰地陈述出你要解决的问题。确定程序所需地输入量和程序所产生的输出量。为你的程序设计算法将算法转化为 MATLAB 语句调试MATLAB语句。
C语言-数据结构 有向图拓扑排序TopologicalSort（邻接表存储）
BamBoo_Bean的博客
09-14 314
C语言-数据结构 有向图拓扑排序TopologicalSort（邻接表存储）
【数据结构和算法实践-树-LeetCode112-路径总和】
Mao_c的博客
09-13 928
leetcode btree
重头开始嵌入式第四十天（数据结构 队列）
qq_64792908的博客
09-13 542
在 C 语言中，队列（Queue）是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，在表的后端（rear）进行插入操作。int front;int rear;} Queue;在这个定义中：- data 数组用于存储队列中的元素。- front 表示队列的前端，用于删除元素。- rear 表示队列的后端，用于插入元素。队列具有以下特点：- 先进先出（FIFO）：先进入队列的元素先被取出。- 当队列满时，不能再进行插入操作；当队列空时，不能再进行删除操作。
深入理解指针（4）
khjjjgd的博客
09-11 824
如果把函数的指针（地址）作为参数传递给另一个函数 ，当这个指针被用来调用其所指向的函数时，被调用的函数就是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或者条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
数据结构(7.3_1)——二叉排序树
m0_65240792的博客
09-14 422
又称左子树结点值<根结点值<右子树结点值进行中序遍历，可以得到一个递增的有序序列二叉排序树可用于元素的有序组织，搜索。
王道408考研数据结构-树与二叉树-第五章-第一二节
qq_55882840的博客
09-12 1038
树是n(n≥0)个结点的有限集。当n=0时，称为空树。有且仅有一个特定的称为根的结点。当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1,T2,⋯,Tm,其中每个集 合本身又是一棵树，并且称为根的子树。二叉树是一种特殊的树形结构，其特点是每个结点至多只有两棵子树(即二叉树中不存在度 大于2的结点),并且二叉树的子树有左右之分，其次序不能任意颠倒。度为2的树至少有3个结点，而二叉树可以为空。
【数据结构】排序
最新发布
weixin_74076508的博客
09-16 550
3、我们将待排序序列中的第一个元素【44】，插入到有序序列中。①待排序元素【44】和有序序列中元素【3】进行比较，【44】比【3】大则直接插入到有序序列中。②此时有序序列为【3,44】，待排序序列为【38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48】
树、二叉树、特殊的二叉树（堆）、霍夫曼树
qq_73643693的博客
09-14 1065
数据结构与算法之树，该篇文章说明了树的一些用法和基本概念
Java数据结构与算法深度解析
“数据结构与算法Java语言描述，全网最全的Java数据结构与算法详解，包括详细目录、书签和图像描述，适用于深入学习。” 本文主要探讨了数据结构与算法的重要性及其在Java编程中的应用。数据结构和算法是编程的基础...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值