最长无重复子数组

/**
 * 
 * @param arr int整型一维数组 the array
 * @return int整型
 */
function maxLength( arr ) {
    let path=[],max=0;
    for(let i=0;i<arr.length;i++){
        if(path.includes(arr[i])){
            if(path.length>max) max=path.length;
            let idx=path.indexOf(arr[i]);
            path=path.slice(idx+1);
        }
        path.push(arr[i]);
    }
    if(path.length>max) max=path.length;
    return max;
}
module.exports = {
    maxLength : maxLength
};

function maxLength( arr ) {
    // write code here
    let map=new Map()
    let [l,r,res]=[0,0,0]
    while(r<arr.length){
        //有且在左边界的右边
        if(map.has(arr[r])&&map.get(arr[r])>=l){
            //把左边界定到map里面当前重复元素的下一个位置
            l=map.get(arr[r])+1
        }
        //存起来
        map.set(arr[r],r)
        //右边界右移
        r++ 
        //取左右边界差与之前最大长度比，r++了所以是r-l不是r-l+1
        res=Math.max(res,r-l)
    }
    return res
    
}

/**
 * 
 * @param arr int整型一维数组 the array
 * @return int整型
 */
function maxLength( arr ) {
// write code here
     //从数组本身入手
    let max = 0;
    let start = 0;
    for(let i=0;i<arr.length;i++){
        //console.log(arr.indexOf(arr[i],start),i);
        if(arr.indexOf(arr[i],start)<i){//有重复，开始下标右移一位
            start = arr.indexOf(arr[i],start)+1;
        }else{
            max = Math.max(max,i-start+1);//end下标-开始下标+1是长度
           // console.log(max);
        }
    }
    return max;



    //滑动窗口
//     let left = 0,right=0;
//     let max=0;
//     let map={};
//    while(right<arr.length){
//         let curr = arr[right];
//         if(map[curr]){//计数 ++
//             map[curr]++;
//         }else{
//             map[curr]=1;
//         }
//         right++;
//         while(map[curr]>1){//大于1
//             let del = arr[left];
//             if(map[del]){//map里是否已经含有左指针的值，有则 --
//                map[del]--;
//             }else{
//                map[del]=1;
//             }
//             left++;
//         }
//         max = Math.max(max,right-left)
//    }
//     return max;

}
module.exports = {
    maxLength : maxLength
};

/**
 * 
 * @param arr int整型一维数组 the array
 * @return int整型
 */
function maxLength( arr ) {
    // write code here
    let map = new Map();
    let k = 0;
    let max = 1;
    for(let i = 0; i < arr.length; i ++) {
        if(map.has(arr[i])) {
            k = Math.max(k, map.get(arr[i]) + 1);
        }
        map.set(arr[i], i);
        max = Math.max(max, i-k+1);
    }
    return max;
}
module.exports = {
    maxLength : maxLength
};

function maxLength( arr ) {
    // write code here
    let curArr = []
    let max = 0
    arr.forEach(x => {
        if (curArr.includes(x)) {
            max = Math.max(max,curArr.length)
            let idx = curArr.indexOf(x)
            curArr = curArr.slice(idx + 1, curArr.length)
        }
        curArr.push(x)
    })
    max = Math.max(max, curArr.length)
    return max
}

function maxLength( arr ) {
  // write code here
  let newArr = []; // 用来装所有子数组的长度
  let len = arr.length;
  
  if (len === 0 || len === 1) return len;
  let l = 0
  while (l < len) {
      let arr1 = [];
      for (let i = 0; i < len; i++) {
         if (!arr1.includes(arr[i])) {
            arr1.push(arr[i]);
             if (i === len - 1) {
                 newArr.push(arr1.length);
                 l = len
             }
          } else {
              let index = arr1.indexOf(arr[i]);// 找到重复元素的第一个下标
              
              newArr.push(arr1.length);// 记录一次当前数组的长度
              
              arr.splice(0, index + 1);
              
              arr1 = [];
              len = arr.length;
              // 然后从这个下标的下一个开始组合 新的数组
              l++;
              if (i === len - 1) { // 最后一个
                  l = len
              }
              break;
          }
      }
      
  }
  let arr2 = newArr.sort((a, b) => b - a)
  return arr2[0]
  
}

这种代码的复杂度怎么降低

function maxLength(arr) {
            // write code here
            for (var i = 0; i < arr.length; i++) {
                for (var j = i + 1; j < arr.length; j++) {
                    if (arr[i] == arr[j]) {
                        arr.splice(j, 1)
                        j--
                    }
                }
            }
            console.log(arr.length)
        }
        maxLength(arr)