多种方法实现数组去重,数组最大差值和排序算法

1、求数组最大差值

方法一：遍历找最大值和最小值

function maxDiff(arr){
	let min,max;
    for(let i=0;i<arr.length;i++){
        if(arr[i]<min){
            min=arr[i]
        }else if(arr[i]>max){
            max=arr[i]
        }
    }
    return max-min
}

方法二：调用Math方法

function maxDiff(arr){
    let max=Math.max(...arr);
    let min=Math.min(...arr);
    return max - min
}

方法三：排序后首尾相减

function maxDiff(arr){
    arr.sort((a,b) => a-b);
    return arr[arr.length-1]-arr[0]
}

2、实现数组去重

方法一：双重循环找重复后删掉

function removeRepeat(arr){
    for(let i=0;i<arr.length;i++){
        for(let j=i+1;j<arr.length;j++){
            if(arr[i]===arr[j]){
                arr.splice(j,1)
            }
        }
    }
    return arr
}

方法二：排序后删掉相怜相等的元素

function removeRepeat(arr){
    const newArr = arr.sort((a,b) => a-b)
    for(let i=0;i<newArr.length-1;i++){
        if(newArr[i] === newArr[i+1]){
            newArr.splice(i,1)
            i--
        }
    }
    return newArr
}

方法三：调用includes()方法检验新数组是否含有此元素

function removeRepeat(arr){
    const newArr = []
    for(let i=0;i<arr.length;i++){
        if(!newArr.includes(arr[i])){
            newArr.push(arr[i])
        }
    }
    return newArr
}

方法四：根据indexOf()判断索引是否为-1

function removeRepeat(arr){
    const newArr = [];
    for(let i=0;i<arr.length;i++){
        if(newArr.indexOf(arr[i]) === -1){
            newArr.push(arr[i]);
        }
    }
    return newArr
}

方法五：根据filter过滤

function removeRepeat(arr) {
    // const newArr = arr.filter(function(element,index){
    //     return arr.indexOf(element)  === index
    // })

    return arr.filter((e, index) => arr.indexOf(e) === index)
}

方法六：set集合自动筛选

function removeRepeat(arr) {

    // return [...new Set(arr)]

    return Array.from(new Set(arr))
}

3、面试常见数组排序算法

1.冒泡排序：

function bubbleSort(arr){
    let temp;
    for(let i=0;i<arr.length-1;i++){
        for(let j=i;j<arr.length;j++){
            if(arr[j]>arr[j+1]){
                temp=arr[j];
                arr[j]=arr[j+1]
                arr[j+1]=temp
            }
        }
    }
    return arr
}

2.插入排序：

function insertionSort(arr){
    let preIndex,temp;
    for(let i=1;i<arr.length;i++){
        preIndex=i-1;
        temp =arr[i];
        while(preIndex>=0 && arr[preIndex]>temp){
            arr[preIndex+1] = arr[preIndex]
            preIndex--
        }
        arr[preIndex+1]=temp
    }
    return arr
}

3.选择排序：

function selectionSort(arr){
    let minIndex,temp;
    for(let i=0;i<arr.length-1;i++){
        minIndex = i;
        for(let j=i+1;j<arr.length;j++){
            if(arr[minIndex]>arr[j]){
                minIndex = j;
            }
        }
        temp = arr[i];
        arr[i]=arr[minIndex];
        arr[minIndex]=temp
    }
    return arr
}

4.归并排序

function mergeSort(arr){
    if(arr.length<2){
        return arr
    }
    var middle = Math.floor(arr.length/2),
    left = arr.slice(0,middle),
    right = arr.slice(middle);
    return merge(mergeSort(left),mergeSort(right))
}
function merge(left,right){
    let result = [];
    while(left.length>0 && right.length>0){
        if(left[0]>right[0]){
            result.push(right.shift())
        }else{
            result.push(left.shift())
        }
    }
    while(left.length){
        result.push(left.shift())
    }
    while(right.length){
        result.push(right.shift())
    }
    return result
}

5.快速排序

function quickSort(arr) {
    if (arr.length < 2) return arr;
    var pivotIndex = Math.floor(arr.length / 2),
        pivot = arr.splice(pivotIndex, 1)[0],
        left = [],
        right = [];
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] > pivot) {
            right.push(a[i])
        } else {
            left.push(a[i])
        }
    }
    return quickSort(left).concat([pivot], quickSort(right))
}