day01

Bugman.

于 2023-11-28 17:13:22 发布

阅读量932

点赞数 16

分类专栏：剑指Offer 文章标签：算法

本文链接：https://blog.csdn.net/m0_63732435/article/details/134661745

版权

剑指Offer 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1. 找出数组中重复的数字。

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

示例 1：

输入：
[2, 3, 1, 0, 2, 5, 3]
输出：2 或 3

限制：

2 <= n <= 100000

方法一：哈希

class Solution {
    public int findRepeatNumber(int[] nums) {
        Set<Integer> set = new HashSet<>();
        for(int num : nums){
            if(set.contains(num)) return num;
            set.add(num);
        }
        return -1;
    }
}

方式二：鸽巢原理(最优解)

class Solution {
    public int findRepeatDocument(int[] documents) {
        for(int i=0; i < documents.length; i++){
            while(i!=documents[i]){
                if(documents[i]==documents[documents[i]]){
                    return documents[i];
                }
                int temp = documents[documents[i]];
                documents[documents[i]] = documents[i];
                documents[i] = temp;
            }
        }
         return -1;
    }
}

以下是算法的执行流程

这种原地置换的想法确实挺精妙的。

1、题目明确说明了数组长度为n，范围为 n-1，也就是若无重复元素排序后下标0123对应的数字就应该是0123；

2、对数组排序，其实也就是让萝卜归位，1号坑要放1号萝卜，2号坑要放2号萝卜......排序过程中查找有无重复元素。先考虑没有重复元素的情况：

 nums[i]     3  1  0  2   萝卜   
     i       0  1  2  3   坑

0号坑说我要的是0号萝卜，不要3号萝卜，所以会去和3号坑的萝卜交换，因为如果0号坑拿了3号坑的3号萝卜，那说明3号坑装的也肯定是别人家的萝卜，所以要跟3号坑换，换完是这样的：

 nums[i]     2  1  0  3   萝卜  
     i       0  1  2  3   坑

然而0号坑还没找到自己的萝卜，它不要2号萝卜，又去和2号坑的萝卜交换，换完是这样的：

 nums[i]     0  1  2  3   萝卜 
     i       0  1  2  3   坑

这时候刚好就是一一对应的，交换过程也不会出现不同坑有相同编号的萝卜。要注意交换用的是while，也就是0号坑只有拿到0号萝卜，1号坑才能开始找自己的萝卜。

3、如果有重复元素，例如：

 nums[i]     1  2  3  2    萝卜
     i       0  1  2  3    坑

同样的，0号坑不要1号，先和1号坑交换，交换完这样的：

 nums[i]     2  1  3  2    萝卜
     i       0  1  2  3    坑

0号坑不要2号萝卜，去和2号坑交换，交换完这样的：

 nums[i]     3  1  2  2    萝卜
     i       0  1  2  3    坑

0号坑不要3号萝卜，去和3号坑交换，交换完这样的：

 nums[i]     2  1  2  3    萝卜
     i       0  1  2  3    坑

0号坑不要2号萝卜，去和2号坑交换，结果发现你2号坑也是2号萝卜，那我还换个锤子，同时也说明有重复元素出现。

4、总结

其实这种原地交换就是为了降低空间复杂度，只需多要1个坑来周转交换的萝卜就好了，空间复杂度O（1）。

2. 二维数组中的查找

难度中等937

在一个 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。

限制：

0 <= n <= 1000
0 <= m <= 1000

题解：

前置知识：在二维数组中，如果直接调用b.length方法，返回的是b数组的行数，

如果是b[0].length方法，则返回的是第0行所代表的长度

思路

答案

class Solution {
    public boolean findTargetIn2DPlants(int[][] plants, int target) {
        if(plants==null || plants.length<=0 || plants[0].length<=0){
            return false;
        }
        //从二维数组左下角开始查找
        int rows = plants.length;
        int cols = plants[0].length;
        int row = rows-1;
        int col = 0;
        //注意这里行是>=0
        while(row>=0 && col<cols){
            if(plants[row][col]>target){
                row--;
            }else if(plants[row][col]<target){
                col++;
            }else{
                return true;
            }
        }
        return false;
    }
}

3. 替换空格

替换空格

用Java api

class Solution {
    public String pathEncryption(String path) {
          //思路是根据原来的字符串重新拼接一个字符串
          StringBuilder builder = new StringBuilder();
          for(int i=0; i < path.length(); i++){
               if(path.charAt(i)=='.'){
                    builder.append(' ');
               }else{
                    builder.append(path.charAt(i));
               }
          }
          return builder.toString();
     }
}