面试中常见的数组操作

在一些面试的过程中经常会遇到数组相关的一些题目，下面通过一些题目的分类来了解一下

1.排序问题

数组的排序问题是非常基础和常见的题目，可以通过自己写排序方法，或者数组的sort 方法直接进行排序

sort排序

let arr = [2,3,10,5,6,8,1]
arr.sort((a,b)=>{
    return a-b     //升序
})

冒泡排序：冒泡排序的主要原则就是通过循环，两两比较找到数组中最大的元素，排到数组的最右边，完成数组的排序

代码如下

let arr = [1,12,45,22,34,2,56,87,57]
  function bubbleSort(arr){
      for(let i = arr.length;i>0;i--){
          for(let j =0; j<i;j++){
              if(arr[j]>arr[j+1]){ 
                  [arr[j],arr[j+1]] =[arr[j+1],arr[j]]
              }
          }
      }
      return arr

  }

  console.log(bubbleSort(arr))

选择排序：选择排序是通过每一次比较找到的是数组中的最小值

let arr = [1,12,45,22,34,2,56,87,57]
  function selectSort(arr){
      let min 
      for (let i =0 ;i<arr.length;i++){
          min= arr[i]
          for(let j=i+1;j<arr.length;j++){
              if(arr[j]<min){
                  [arr[j],min] = [min,arr[j]]
              }
          }
          arr[i] = min
      }
      return arr

  }
  console.log(selectSort(arr))

冒泡排序和选择排序的时间复杂度为O(n^2), 时间复杂度改，下面来看一下快速排序，时间复杂度为O(nlog(n))

快速排序  快速排序的核心思想就是分治，通过选择一个中间元，将比中间元小的元素存放至中间元的左边，将比中间元大的元素存放至中间元的右边，递归操作，完成对数组的排序

 function quick(array,left,right){
    let index
    if(array.length>1){
        index = privoit(array,left,right);
        if(left < index-1){
            quick(array,0,index-1)
        }
        if(index < right){
            quick(array,index,right)
        }
    }
    return array
}

function privoit(array,left,right){
    let middle = array[Math.floor((left+right)/2)]
        i = left
        j = right
    while (i<=j){
        while(array[i]<middle){
            i++
        }
        while(array[j]>middle){
            j--
        }
        if(i<= j){
            [array[i],array[j]] = [array[j],array[i]]
            i++
            j--
        }
    }
    return i
}
  console.log(quick(arr1,0,arr1.length-1))

2. 数组扁平化

数组的扁平化主要是采取了递归的方式 或者可以使用ES6中的展开操作符

扫描二维码关注公众号，回复： 9167845 查看本文章

let arr = [1,[2,[3,4]]]
function  flatten(arr){
    let newArr = []
    arr.forEach(item => {
        if(Array.isArray(item)){
           newArr = newArr.concat(flatten(item)) 
        }else{
            newArr.push(item)
        }
        
    });
    return newArr
}
console.log(flatten(arr))

let arr = [1,[2,[3,4]]]
function  flatten(arr){
    while(arr.some(item=>Array.isArray(item))){
          arr = [].concat(...arr)
    }
    return arr
}
console.log(flatten(arr))

还可以通过先将数组拼成字符串，再分割成数组的方法

let arr = [1,[2,[3,4]]]
console.log(arr.join(',').split(','))
function  flatten(arr){
    return arr.join(',').split(',').map(item=>{
          return Number(item)
    })
}
console.log(flatten(arr))

3. 数组的去重

let arr  = [1,2,3,4,5,5] 
function diff(arr){
    let newArr = []
    for(let i =0;i<arr.length;i++){
        if(newArr.indexOf(arr[i])===-1){
            newArr.push(arr[i])
        }
    }
    return  newArr
}
function diff(arr){
    let newArr = []
    let obj = {}
    for(let i =0;i<arr.length;i++){
        if(!obj[arr[i]]){
            obj[arr[i]] = 1
            console.log(obj)
            newArr.push(arr[i])
        }
    }
    return  newArr
}
console.log(diff(arr))
console.log([...new Set(arr)])
console.log(Array.from(new Set(arr)))

在这里补充一道题吧，如何计算数组中出现次数最多的元素，思路和第二种数组去重的方法类似，将数组中的元素作为对象的key值

et arr  = [1,2,3,4,5,5,6,6,6] 
function maxarr(arr){
    let [obj,max,name] = [{},1,'']
        arr.forEach(item=>{
            if(obj[item]){
                obj[item]++;
                if(max<obj[item]){
                    max = obj[item]
                    name = item
                }
            }else{
                obj[item] = 1
            }
        })
    console.log(obj)
    return name
}
console.log('sdsd',maxarr(arr))