算法总结之 最长的可整合子数组长度

如果一个数组在排序之后，每相邻两个数差的绝对值都为1，则该数组为可整合数组

方法一（通俗的做法）

  考察每个子数组-------> 复制成新数组------> 新数组排序------>验证是否符合

代码：

package TT;

import java.util.Arrays;

public class test61 {
  
      public static int getLIL1(int[] arr){
          
         if(arr==null || arr.length==0){
             return 0;
         }
         
         int len = 0;
         for(int i=0; i<arr.length; i++){
             for(int j=i; j<arr.length; j++){
                  if(isIntegrated(arr,i,j)){
                        len=Math.max(len,j-i+1);
                  }
             }
         }
         return len;
      }
     
      public static boolean isIntegrated(int[] arr, int left, int right){
          int[] newArr = Arrays.copyOfRange(arr, left, right+1);
          Arrays.sort(newArr);
          for(int i = 1; i<newArr.length; i++){
                  if(newArr[i-1] != newArr[i]-1){
                      return false;
                  }
          }
          return true;
      }
      
      
      public static void main(String[] args){
          
          int[] arr = new int[7];
          arr[0]=5;
          arr[1]=5;
          arr[2]=3;
          arr[3]=2;
          arr[4]=6;
          arr[5]=4;
          arr[6]=3;
    
         int x = getLIL1(arr);
         System.out.println(x);
          
      }
       
}

改进的方法：

  加速验证过程，前方高能！！！！！-------------------------------------------》》》》》》》》》

  判断一个数组是否可是可整合,

              如果     max-min+1= 元素个数  即为：6-2+1=5  那么这个数组就是可整合数组

废话不说多说！

package TT;


import java.util.HashSet;



public class test61 {
  
   public static int getLIL2(int[] arr){
       
        if(arr==null || arr.length==0){
            return 0;
        }
        
        int len = 0;
        int max =0;
        int min =0;
        HashSet<Integer> set = new HashSet<Integer>();
        for (int i = 0; i < arr.length; i++) {
             max = Integer.MIN_VALUE;
             min = Integer.MAX_VALUE;
             for(int j =i; j<arr.length; j++){
                 
                  if(set.contains(arr[j])){
                      break;
                  }
                  set.add(arr[j]);
                  max=Math.max(max, arr[j]);
                  min=Math.min(min, arr[j]);
                  
                  if ( max-min == j-i) {
                      len=Math.max(len, j-i+1);
                    
                }
                  
             }
             set.clear();
        }
       return len;
   }
    
    
    
    
    
   public static void main(String[] args){
       
       int[] arr = new int[7];
       arr[0]=5;
       arr[1]=5;
       arr[2]=3;
       arr[3]=2;
       arr[4]=6;
       arr[5]=4;
       arr[6]=3;
 
      int x = getLIL2(arr);
      System.out.println(x);
       
   } 
   
   
   
}

 其实重点在于：

   不重复的数组中 ，下表的值 i   和    j 之差  j-i   与最大值和最小值max 和 min 的差值 是有关系的 也有数目相关性

   用set集合获取到不重复的数组

   然后进行时刻的判断 更新最大值

 

       最内层for循环去做事情，用set去操作，做完了时候要清空一下set

       外层下次循环继续使用，同时下次使用时候要用 min max重新初始化 

        我们的核心是一直记录最大的长度，其他的是中间产物。