[剑指Offer]数组中重复的数字

最新推荐文章于 2021-10-02 21:39:01 发布
勤劳de码农
最新推荐文章于 2021-10-02 21:39:01 发布
阅读量106
点赞数
分类专栏：数据结构与算法
原文链接：https://blog.youkuaiyun.com/shakespeare001/article/details/51252161
版权
数据结构与算法专栏收录该内容
6 篇文章
订阅专栏
                        
    原创 
    [剑指Offer]数组中重复的数字 
   
2016-04-26 17:20:18山代王阅读数 2730更多 
      分类专栏： 
       数据结构与算法  
       算法整理（Java版）  
     
    版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。  
      本文链接： 
     https://blog.youkuaiyun.com/shakespeare001/article/details/51252161 
    
题目描述： 
     在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是重复的数字2或者3。 
    
 思路一： 
         根据题目描述，数组里面的值范围在0~n-1，此时就可以利用数组的值作为我们数组的下标，当数组中存在重复的数字时，那它们就指向了同一个以该值为下标的数组元素。利用这一点，我们在遍历访问数组的时候，每访问一个元素，将该元素值作为数组元素下标，只要就指向了一个新的数组元素，同时将这个新的元素值 + 数组的长度length，如果此时新元素值>= 2 * length，说明在这之前已被更改过，也就说明存在重复数字。代码如下： 
    
          public boolean duplicate(int numbers[],int length,int [] duplication) {
         
          if(numbers == 
          
          null){
         
          return 
          
          false;
         
                  }
         
          if(length != numbers.length){
         
          return 
          
          false;
         
                  }
         
          int index;
         
          for(
          
          int i = 
          
          0; i < length; i++){
         
                      index = numbers[i];
         
          if(index >= length){
         
                          index -= length;
         
                      }
         
                      numbers[index] += length;    
          
          //先更改一次
         
          if(numbers[index] >= 
          
          2 * length){
         
                          duplication[
          
          0] = index;
         
          return 
          
          true;
         
                      }
         
                  }
         
          return 
          
          false;
         
              }
         
     上面的的for循环也可以利用求余的方法来实现，如下： 
    
          <span style=
          
          "white-space:pre">	</span>
          
          for(
          
          int i = 
          
          0; i < length; i++){
         
                      index = numbers[i];
         
                      index = index % length;
         
                      numbers[index] += length;
         
          if(numbers[index] >= 
          
          2 * length){
         
                          duplication[
          
          0] = index;
         
          return 
          
          true;
         
                      }
         
                <span style=
          
          "white-space:pre">	</span>}
         
     时间复杂度为O(n)，空间复杂度为O(1)，但思路一这种方法的缺点就是，我们已经擅自改变了传参过来的数组元素内容。 
    
思路二： 
         利用字符串的一些特点来解题，如果一个字符串中存在相同的字符，它们在字符串中的位置肯定不一样，那通过indexOf和lastIndexOf获取到的索引值肯定就不同；反过来，如果字符串中没有相同的字符，那么每个字符通过indexOf和lastIndexOf获取到的索引值肯定相等。所以，我们的思路就是，先将数组元素组拼成字符串，然后利用上面的字符串特点解题。代码如下： 
          
          public static boolean duplicate(int numbers[],int length,int [] duplication) {  
         
          if(numbers == 
          
          null){  
         
          return 
          
          false;  
         
                  }  
         
          if(length != numbers.length){  
         
          return 
          
          false;  
         
                  }  
         
                  StringBuilder sb = 
          
          new StringBuilder();  
         
          for(
          
          int i = 
          
          0; i < length; i++){  
         
                      sb.append(
          
          "#").append(numbers[i]).append(
          
          "#");
          
          //加入分隔符  
         
                  }  
         
                  String str = sb.toString();  
         
          for(
          
          int i = 
          
          0; i < length; i++){  
         
          if(str.indexOf(
          
          "#" + numbers[i] + 
          
          "#") != str.lastIndexOf(
          
          "#" + numbers[i] + 
          
          "#")){  
         
                         duplication[
          
          0] = numbers[i];  
         
          return 
          
          true;  
         
                     }  
         
                  }  
         
          return 
          
          false;  
         
              }
         
     这种方式的好处就是，我们没有改变原来数组的内容，但是额外增加了一个StringBuilder 。 
    
思路三： 
         类似思路一的思想，如果存在重复的数字，在遍历过程中，通过数组值作为数组下标的过程中会指向同一个元素，单位了不改变原来的数组，我们自己新增一个数组，存放boolean值，代码如下： 
    
          public boolean duplicate(int numbers[],int length,int [] duplication) {
         
          if(numbers == 
          
          null){
         
          return 
          
          false;
         
                  }
         
          if(length != numbers.length){
         
          return 
          
          false;
         
                  }
         
          boolean[] flag = 
          
          new 
          
          boolean[length];  
         
          int index;
         
          for(
          
          int i = 
          
          0; i < length; i++){
         
                     index = numbers[i];
         
          if(flag[index]){
         
                         duplication[
          
          0] = numbers[i];
         
          return 
          
          true;
         
                     } 
         
                     flag[index] = 
          
          true;
         
                  }
         
          return 
          
          false;
         
              }
         
     和思路二一样，没有改变原来数组的内容，但是额外增加了一个数组变量。 
    
    文章最后发布于: 2016-04-26 17:20:18