刷题（一）--数组

最新推荐文章于 2021-11-25 23:58:38 发布
最新推荐文章于 2021-11-25 23:58:38 发布
阅读量659 收藏 1
点赞数
分类专栏： 算法与数据结构 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49449205/article/details/119029357
版权

文章目录

二维数组中的查找

题目描述：在一个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

方法一：暴力破解法
思路如下：依次遍历数组的 每一行和列，找到返回true，未找到则返回false。

代码：

class Solution{
public  boolean findNumberIn2DArray(int[][] matrix,int target){
        if(matrix == null || matrix.length==0||matrix[0].length==0){
            return false;
        }

        int rows = matrix.length,colums = matrix[0].length;
        for (int i = 0;i<rows;i++){
            for (int j = 0;j<colums;j++){
                if(matrix[i][j] == target){
                    return true;
                }
            }
        }
        return false;
    }
}

时间复杂度：O（nm）
控件复杂度：O（1）
方法二：线性查找
思路如下：由于给定的二维数组具备每行从左到右递增，每列从上到下递增，每当访问到一个元素时，可以排除数组中的部分元素，从左上角开始查找，如果相等则返回true，如果当前元素大于target则移到左边一列，如果当前元素小于目标值则移到下边一行。

代码：

class Solution {
    public boolean findNumberIn2DArray(int[][] matrix, int target) {
        if(matrix == null||matrix.length == 0||matrix[0].length==0){
            return false;
        }

        int rows = matrix.length,colunms = matrix[0].length;
        int row = 0;
        int colunm = colunms-1;
        while(row < rows && colunm >= 0){
            int num = matrix[row][colunm];
            if(num == target){
                return true;
            }else if(num>target){
                colunm--;
            }else{
                row++;
           }
        }
        return false;
    }
}

时间复杂度：O（n+m）
空间复杂度：O（1）
方法三：二分法
思路：因为所给数组皆有序，我们可以对每一行进行二分查找。随后挪至下一行，直至结束。
代码：

class Solution {
    public boolean findNumberIn2DArray(int[][] matrix, int target) {
 if(matrix == null || matrix.length == 0 || matrix[0].length == 0) {
         return false;
     }

     for(int i=0;i<matrix.length;i++){
         int left = 0,right = matrix[0].length-1;
         while(left<=right){
           int mid = left+(right-left)/2;
           if(matrix[i][mid]==target){
               return true;
           }else if(matrix[i][mid]>target){
               right = mid-1;
           }else{
               left = mid+1;
           }
         }
     }
     return false;
    }
}

时间复杂度：因为二分复杂度为O（log2n），加上for循环，应为O（nlog2n）。
空间复杂度：O（1）

旋转数组的最小值

题目描述：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。

示例1：

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

示例2：

输入：[2,2,2,0,1]
输出：0

思路描述：包含重复元素的升序数组旋转后如下
在这里插入图片描述
左边界为low，右边界为high，中点为pivot
将中轴元素与右边界比较，有如下三种情况。
①:在这里插入图片描述
②：在这里插入图片描述
③：在这里插入图片描述
代码：

class Solution {
    public int minArray(int[] numbers) {
     int left = 0,right = numbers.length-1;
     while(left<right){
         int mid = left+(right-left)/2;
         if(numbers[mid]>numbers[right]){
             left = mid+1;
         }else if(numbers[mid]<numbers[left]){
             right = mid;
         }else{
             right--;
         }
     }
     return numbers[left];
    }
}

最坏情况时间复杂度（元素全相同）：O（n）
平均时间复杂度：O（logn）
空间复杂度：O（1）

调整数组使得奇数在前偶数在后

题目描述：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。

示例：

输入：nums = [1,2,3,4]
输出：[1,3,2,4] 
注：[3,1,2,4] 也是正确的答案之一。

方法一：辅助数组
思路如下：：创建为原数组大小的新数组，遍历两遍数组，第一遍遍历奇数，放入新数组，第二遍遍历偶数，放入新数组。

代码：

class Soultion{
 public  int[] exchange(int[] nums){
        int n = nums.length;
        int[] res = new int[n];
        int index = 0;
        for (int num:nums){
            if(num%2==1){
                res[index++] = num;
            }
        }
        for (int num:nums){
            if (num%2==0){
                res[index++] = num;
            }
        }
        return res;
    }
 }

时间复杂度：O(n)
空间复杂度：O（n）

方法二：头尾双指针
思路：left指向头，right指向尾。left右移直到指向偶数，right左移直到指向奇数。交换left和right的数字，直到left>right。若left>right,则break结束。

代码：

class Solution {
    public int[] exchange(int[] nums) {
     int pre = 0,post = nums.length-1;
     while(pre<=post){
         while(pre<=post && nums[pre] % 2 == 1){
             pre++;
         }
         while(pre<=post && nums[post] % 2 == 0){
             post--;
         }
         if(pre>post){
             break;
         }

         int cur = nums[post];
         nums[post] = nums[pre];
         nums[pre] = cur;
     }
     return nums;
    }
}

时间复杂度
方法三：快慢指针
思路：slow和fast都从头开始遍历，fast右移，如若遇到奇数，则和slow位置数字交换，slow++，fast++。没有遇到奇数，fast++，直至末尾结束。
代码：

class Solution {
    public int[] exchange(int[] nums) {
     int slow = 0,fast = 0;
     while(fast<nums.length){
         if(nums[fast]%2 == 1){
             int tmp = nums[slow];
             nums[slow] = nums[fast];
             nums[fast] = tmp;
             slow++;
         }
         fast++;
     }
     return nums;
    }
}

顺时针打印矩阵

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

示例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]

方法一：模拟矩阵打印路径
思路如下：
按照打印矩阵的路径，初始位置为左上角，初始方向向右，当超出路径或者进入到之前已经访问过的位置，就顺时针旋转进入下一个方向。
我们使用一个辅助矩阵来标记是否访问过这个位置。至于旋转的时机，我们使用一个二维数组，实现四个方向的改变，每次更新下一行和下一列的下标，具体实现请看代码。

代码：

class Solution {
    public int[] spiralOrder(int[][] matrix) {
     if( matrix == null || matrix.length == 0 || matrix[0].length == 0){
         return new int[0];
     }
     int rows = matrix.length,colums = matrix[0].length;
     boolean[][] vis = new boolean[rows][colums];
     int total = rows*colums;
     int[] n = new int[total];
     int row =0,colum = 0;
     int[][] directions = {{0,1},{1,0},{0,-1},{-1,0}};
     int directionIndex = 0;
     for(int i=0;i<total;i++){
         n[i] = matrix[row][colum];
         vis[row][colum] = true;
         int nextRow = row+directions[directionIndex][0],nextColum = colum+directions[directionIndex][1];  //在遍历行时，nextRow的值不变，nextColum的值加1，直到边界，反之亦然。
         if(nextRow<0||nextRow>=rows||nextColum<0||nextColum>=colums||vis[nextRow][nextColum]){
             directionIndex = (directionIndex+1)%4;  //在超过边界或是到访问过的位置，更新dir的值
         }
         row+=directions[directionIndex][0];
         colum+=directions[directionIndex][1];
     } 
     return n;
    }  
}

时间复杂度：O（mn），m，n分别为行列数。
空间复杂度：O（mn）。需要辅助矩阵。

方法二：按层模拟
思路如下：我们可以把矩阵看成很多层，首先打印最外层元素，其次打印内层元素，直到结束。
如下所示，每一层都按同样的顺序打印，就像洋葱一样一层一层剥开。

[[1, 1, 1, 1, 1, 1, 1],
 [1, 2, 2, 2, 2, 2, 1],
 [1, 2, 3, 3, 3, 2, 1],
 [1, 2, 2, 2, 2, 2, 1],
 [1, 1, 1, 1, 1, 1, 1]]

左上角位于 (\textit{top}, \textit{left})(top,left)，右下角位于 (\textit{bottom}, \textit{right})(bottom,right)，按照如下顺序遍历当前层的元素。

  • 从左到右遍历上侧元素，依次为 (\textit{top}, \textit{left})(top,left) 到 (\textit{top}, \textit{right})(top,right)。
  • 从上到下遍历右侧元素，依次为 (\textit{top} + 1, \textit{right})(top+1,right) 到 (\textit{bottom}, \textit{right})(bottom,right)。
  • 如果 \textit{left} < \textit{right}left<right 且 \textit{top} < \textit{bottom}top<bottom，则从右到左遍历下侧元素，依次为 (\textit{bottom}, \textit{right} - 1)(bottom,right−1) 到 (\textit{bottom}, \textit{left} + 1)(bottom,left+1)，以及从下到上遍历左侧元素，依次为 (\textit{bottom}, \textit{left})(bottom,left) 到 (\textit{top} + 1, \textit{left})(top+1,left)

遍历完当前层的元素之后，将 \textit{left}left 和 \textit{top}top 分别增加 11，将 \textit{right}right 和 \textit{bottom}bottom 分别减少 11，进入下一层继续遍历，直到遍历完所有元素为止。
代码：

class Solution {
    public int[] spiralOrder(int[][] matrix) {
    if(matrix == null || matrix.length == 0 || matrix[0].length == 0){
        return new int[0];
    }
    int rows = matrix.length,colums = matrix[0].length;
    int[] n = new int[rows*colums];
    int index = 0;
    int left = 0,right = colums-1,top = 0,bottom = rows-1;
    while(left<=right && top<=bottom){
        for(int colum = left;colum<=right;colum++){
            n[index++]  = matrix[top][colum];
        }
        for(int row = top+1;row<=bottom;row++){
            n[index++] = matrix[row][right];
        }
        if(left<right&&top<bottom){
            for(int colum = right-1;colum>left;colum--){
                n[index++] = matrix[bottom][colum];
            }
            for(int row= bottom;row>top;row--){
                n[index++] = matrix[row][left];
            }
        }
        left++;
        right--;
        top++;
        bottom--;
    } 
    return n;
    }  
}

时间复杂度：O（nm），n，m为行列数，每个元素都需要访问。
空间复杂度：O（1）

数组中出现次数超过一半的数字

题目描述：数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例：

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

方法一：哈希表
思路如下：我们可以使用哈希映射来保存每个元素和它出现的次数，键位元素，值为该元素出现的次数。
循环遍历数组将元素存入哈希表。之后遍历哈希表返回值最大的键。
代码：

class Solution {
    public int majorityElement(int[] nums) {
    Map<Integer,Integer> counts = countNums(nums);

    Map.Entry<Integer,Integer> majorityElement = null;
    for(Map.Entry<Integer,Integer> entry:counts.entrySet()){
        if(majorityElement == null||entry.getValue()>majorityElement.getValue()){
            majorityElement = entry;
        }
    }
    return majorityElement.getKey();
    }
    private Map<Integer,Integer> countNums(int[] nums){
        Map<Integer,Integer> counts = new HashMap<Integer,Integer>();
        for(int num:nums){
            if(!counts.containsKey(num)){
                counts.put(num,1);
            }else{
                counts.put(num,counts.get(num)+1);
            }
        }
        return counts;
    }
}

时间复杂度：O（n）
空间复杂度：O（n）
方法二：排序
思路如下：如果将数组中的元素排序，无论递增或是递减，那么下标为n/2的元素（下标从0起）一定是众数。
无论数组为偶数还是奇数，因为目标元素出现的次数大于一半，所以n/2的下标位置必定为目标元素。
代码：

class Solution {
    public int majorityElement(int[] nums) {
        Arrays.sort(nums);
        return nums[nums.length / 2];
    }
}

时间复杂度：O（nlog n）
空间复杂度：O(logn)。如果使用语言自带的排序算法，需要使用 O(\log n)O(logn) 的栈空间。如果自己编写堆排序，则只需要使用 O(1)O(1) 的额外空间
方法三：分治策略
思路如下：如果数 a 是数组 nums 的众数，如果我们将 nums 分成两部分，那么 a 必定是至少一部分的众数。这样以来，我们就可以使用分治法解决这个问题：将数组分成左右两部分，分别求出左半部分的众数 a1 以及右半部分的众数 a2，随后在 a1 和 a2 中选出正确的众数。
代码：

class Solution {
   
    public int countInRange(int[] nums,int num,int lo,int hi){
        int count = 0;
        for(int i=lo;i<=hi;i++){
            if(nums[i]==num){
                count++;
            }
        }
        return count;
    }
    private int majorityElementRec(int[] nums,int lo,int hi){
        if(lo == hi) {
            return nums[lo];
        }

        int mid = (hi-lo)/2+lo;
        int left = majorityElementRec(nums,lo,mid);
        int right = majorityElementRec(nums,mid+1,hi);

        if(left == right){
            return left;
        }

        int leftCount = countInRange(nums,left,lo,hi);
        int rightCount = countInRange(nums,right,lo,hi);

        return leftCount>rightCount?left:right;
    }
     public int majorityElement(int[] nums) {
      return majorityElementRec(nums,0,nums.length-1);
    }
}

时间复杂度：O（nlog n）
空间复杂度：O（log n），虽然没有直接借助辅助空间，但是在递归过程中使用了额外的栈空间（栈帧）。

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

题目描述：统计一个数字在排序数组中出现的次数。

示例1：

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

示例2：

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

思路如下：首先，最简单的方法当然是遍历一遍数组，用变量记录目标元素出现的次数，但是这个方法的时间复杂度为O（n），并且没有用到数组升序的条件。
我们可以考虑使用二分法解题，要记录target出现的次数，那么就要找到target第一次出现的位置，和target最后一次出现的后一个位置。结果就是rightIndex-leftIndex+1。
代码：

class Solution {
    public int search(int[] nums, int target) {
    int leftIndex = binarySearch(nums,target,true);
    int rightIndex = binarySearch(nums,target,false)-1;
    if(leftIndex<=rightIndex&&rightIndex<nums.length&&nums[leftIndex]==target&&nums[rightIndex]==target){
        return rightIndex-leftIndex+1;
    }
    return 0;
    }
    public int binarySearch(int[] nums,int target,boolean lower){
        int left = 0,right = nums.length-1,ans = nums.length;
        while(left<=right){
            int mid = (left+right)/2;
            if(nums[mid]>target||(lower&&nums[mid]>=target)){
                right = mid-1;
                ans = mid;
            }else{
                left =mid+1;
            }
        }
        return ans;
    }

}

求数组中最小的k个数

题目描述：输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。

示例1：

输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]

示例2：

输入：arr = [0,1,2,1], k = 1
输出：[0]

方法一：排序
对数组进行排序然后取出前k个数
代码：

class Solution {
   public int[] getLeastNumbers(int[] arr, int k) {
   int[] v = new int[k];
   Arrays.sort(arr);
   for(int i=0;i<k;i++){
       v[i] = arr[i];
   }
   return v;
   }
}

时间复杂度：O（nlog n）
空间复杂度：O（log n）
方法二：自建堆
我们使用一个大根堆实时维护数组的前k个值。先把k个数存在大根堆，然后从k+1个数遍历，如果比堆顶的数小，就让堆顶的数弹出，插入当前遍历到的数。最后把大根堆里的数放入数组返回。
代码：

class Solution {
   public int[] getLeastNumbers(int[] arr, int k) {
   int[] v = new int[k];
   if(k == 0){
       return v;
   }
   PriorityQueue<Integer> queue = new PriorityQueue<Integer>(new Comparator<Integer>(){
       public int compare(Integer num1,Integer num2){
           return num2-num1;
       }
   });
   for(int i =0 ;i<k;++i){
       queue.offer(arr[i]);
   }
   for(int i = k;i<arr.length;++i){
       if(queue.peek()>arr[i]){
           queue.poll();
           queue.offer(arr[i]);
       }
   }
   for(int i =0;i<k;++i){
       v[i] = queue.poll();
   }
   return v;
   }
}

时间复杂度：O（nlog k）
空间复杂度：O（k）

降温vae+
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
NOI1.8.21二维数组右上左下遍历 题解(C++)
jerry20183的博客
02-14 1434
NOI1.8.21二维数组右上左下遍历 题解(C++) 哈哈，又来看题解了？ 画面有点模糊，不要在意… 今天的这一道题跟遍历二维数组有关系，其实这道题并不那么的难，只不过有考眼力的成分存在，像作者这种眼镜一摘世界就有两个的人，看了好久都看不出来，不说了，请听题： 21:二维数组右上左下遍历 总时间限制: 1000ms 内存限制: 65536kB 描述 给定一个row行col列的整数数组array...
Leetcode面试题04. 二维数组中的查找
test121210的博客
05-24 401
面试题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,
思维-各种矩阵
FAsatan0的博客
07-12 258
Acwing 3732. 矩阵复原 题意：一个 n×m 的整数矩阵，已知其每一行从左到右拥有哪些元素，每一列从上到下拥有哪些元素。 但是，行和列的具体顺序并不确定。 请你根据已知的信息，将矩阵复原并输出。 分析：开始想的是给了每一行 那记录第一个元素，在后面的列中找到第一列然后按照第一列的顺序 去n行中匹配第一个元素 输出这一行 后来把对应改了一下 标记每个元素的行号 之后再对应 找 输出 写法1 #include<iostream> #include<cstdio> #includ
矩阵每一行升序排列c语言,设M是一个n*n的整数矩阵，其中每一行和每一列的元素都按升序排列，设计分治算法确定一个给定的整数x是否M...
weixin_30290193的博客
05-24 1765
满意答案运行后#包括中长苏木贝尔(长总和[] []，廉政克)/ /定义的苏木贝尔功能，求和的作用{ INT H，L;长，他= 0;(H = 0，H (L = 0，L (H ==(G-1))/ /最后一行是不计算(L ==(G-1))继续; / /最后一个计算(H == 1)/ /对角线不算数((H + L)，==(G-1))继续; / /计算反对角线 BR />的printf(“ - %LD...
对于一个m*n的整数矩阵，其中每一行和每一列的元素都按升序排列，设计一个高效的算法判断一个数值是否存在，并给出位置
热门推荐
hu10131013的博客
08-24 16万+
package com.huanchuang.arvin.vo; public class Finder { private String findElement(int[][] matrix, int target) { int row = 0, column = 0; // 只要行还没有达到最大值就继续执行 while (row <...
LeetCode刷题题解-Java版本
05-18
一个指针 `i` 从数组开头开始，另一个指针 `j` 从数组末尾开始。每次迭代时，计算 `numbers[i] + numbers[j]` 的和，如果和等于 `target`，则找到了解，返回 `i+1` 和 `j+1` 作为结果。如果和小于 `target`，则需要...
【力扣刷题】数组-链表-哈希-双指针
06-21
"数组-链表-哈希-双指针" 在计算机科学中，数组是一种基本的数据结构，用于存储相同类型的数据元素。数组中的每个元素都可以通过下标索引来访问，下标从0开始计数。数组的元素是不能删除的，只能覆盖。不能释放单个...
力扣刷题集-更新至链表
06-21
二分查找是一种常见的搜索算法，用于在一个有序数组中搜索某个目标值。二分查找的前提条件是数组必须是有序的，并且数组中不允许有重复元素。 下面是一个二分查找的示例代码： ```cpp class Solution { public: ...
Leetcode刷题笔记-大厂面试突破集
最新发布
08-15
LeetCode 是一个在线编程练习平台，特别受到程序员和求职者们的欢迎，因为它包含了大量面试常考的算法题目。...通过不断地刷题和实践，能够逐步提升编程水平，为进入大厂或在职场中取得成功打下坚实的基础。
leetcode刷题账号-leetcode:leetcode
07-06
题目我会定时更新一些，数组、链表、栈、队列、二叉树等经典题目 解法会从遍历、递归、动态规划等逐步展开 刷题步骤 修改自己的刷题群备注为自己的 Coding 账号名称，例如 codedrinker 克隆项目到本地，如果有题目的...
分治算法
MingXi__HeXi的博客
03-04 602
分治算法的基本思想：分而治之。将问题分解为好几个部分，递归的解决每一部分，最后综合所有子问题的解，得到原问题的最优解。
算法013：二维数组中的查找-在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断中是否存在
前路无畏的博客
10-25 1万+
题目： 在一个 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，返回t
5×5的二维数组，交换两行
Joway
11-29 1万+
数组 第8题 【描述】 编写一个函数：int swap(int array [5][5], int n, int m )，输入参数是5×5的二维数组，和n、m两个行下标。功能：判断n、m是否在数组范围内，如果不在，则返回0；如果在范围内，则将n行元素与m行元素交换，并返回1。 在main函数中， 创建一个5×5的矩阵，输入矩阵数据，并输入n、m的值。调用前面的函数。如果返回值为0，输出er
LeetCode刷题 面试题04.二维数组中的查找
欧阳七叔的博客
06-09 616
题目要求：在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 分析：查找问题，有特点是每一行都按照从左到右递增，每一列都按照从上到下递增，利用这个特性，可以从右上角开始查找，直到左下角。 bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。
qq_42640983的博客
06-11 4830
import java.util.Arrays; /** * 问题：顺时针螺旋输出数组 * 题目特征：保持一种模式前进，遇到一定条件转换另一种模式前进 * 思路：用一个二维数组来不同取值来控制前进，设置变动的边界为改变的条件 */ public class Test13 { public static void main(String[] args) { int[][] arr = new int[][]{{1,2,3,4},{5,6,7,8},{9,10,11,12}};
面试题29-顺时针打印矩阵
weixin_42127177的博客
11-25 284
题目 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵： 则依次打印出数组：1，2，3，4，8，12，16，15，14，13，9，5，6，7，11，10。 解题思路 我们不用vector，就是二维数组。 当我们遇到一个复杂问题的时候，可以用图形来帮助思考。由于是从外圈到内圈的顺序依次打印的，所以我们可以把矩阵想象成若干个圆。我们可以用一个循环来打印矩阵，每次打印矩阵中的一个圆。假设这个矩阵的行数rows，列数是columns。打印第一圈的左上角的坐标是（0,0），第二圈
给定M*N矩阵，每一行、每一列都按升序排列，判断是否存在某个元素。
bupt8846的专栏
11-18 3201
题目：《程序员面试金典（第5版）》
数据研发笔试Leetcode刷题笔记02：二维数组中的查找
weixin_41961559的博客
04-17 375
文章目录1 题目描述2 解题思路2.1 直接遍历二维数组2.2 巧妙利用标志数性质2.3 递归3 代码实现（Python3）4 复杂度分析 1 题目描述 来源：力扣（LeetCode） 在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 2 解题思路 2.1 直接遍...
剑指offer-面试题4：二维数组中的查找
qq_43568109的博客
03-26 165
题目描述 在一个 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。
C++数组与链表解析：力扣刷题心得
- `vector`是STL容器之一，支持动态增长和收缩，提供插入、删除等操作，而`array`是C++11引入的，是一个固定大小的数组，更接近于C风格的数组。 3. **Java中的二分查找**： - 二分查找适用于有序且无重复元素的...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

降温vae+

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值