1. reserve

讓數(shù)組反轉(zhuǎn)倒置

const arr = [1, 2, 3, 4, 5];
arr.reverse();
console.log(arr); // [5, 4, 3, 2, 1]

const arr = [1, 2, 3, 4, 5];

function reverse(arr) {
  let l = 0;
  let r = arr.length - 1;
  while (l < r) {
    let temp = arr[l];
    arr[l] = arr[r];
    arr[r] = temp;
    l++;
    r--;
  }
}

reverse(arr);
console.log(arr); // [5, 4, 3, 2, 1]

let str = 'abcdef';
str = str
  .split('') // 拆分成數(shù)組
  .reverse() // 數(shù)組可以倒序
  .join(''); // 數(shù)組合并成字符串

console.log(str); // fedcba

2. 排序算法

面試最?？?快速排序和希爾算法 （tips）

原理：如果是想從小到大排序，拿出數(shù)組相鄰兩位數(shù)比較，小的放前，大的放后，如此反復(fù)的交換位置就可以得到排序的效果。

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

原理：首先從原始數(shù)組中找到最小的元素，并把該元素放在數(shù)組的最前面，然后再從剩下的元素中尋找最小的元素，放在之前最小元素的后面，知道排序完畢。

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

原理：從數(shù)組的中間拿一個(gè)值，然后通過這個(gè)值挨個(gè)和數(shù)組里面的值進(jìn)行比較，如果大于的放一邊，小于的放一邊，然后把這些合并，再進(jìn)行比較，如此反復(fù)即可。

function fastSort(arr){
    // 如果只有一位，就沒有必要比較
    if(arr.length<=1){
        return arr;
    }
    // 獲取中間值的索引
    var len = Math.floor(arr.length/2);
    // 截取中間值
    var cur = arr.splice(len,1);
    // 小于中間值放這里面
    var left = [];
    // 大于的放著里面
    var right = [];
    for(var i=0;i<arr.length;i++){
        // 判斷是否大于
        if(cur>arr[i]){
            left.push(arr[i]);
        }else{
            right.push(arr[i]);
        }
    }
    // 通過遞歸，上一輪比較好的數(shù)組合并，并且再次進(jìn)行比較。
    return sortA(left).concat(cur,sortA(right));
}

原理：想象我們斗地主，摸排階段，手里的牌都按照從小到大排序。如果每摸一張牌，我們就把他插入合適的位置，使得它比后面位置的牌小，比前面位置的牌大或者相等。

function insert(arr) {
        for (var i = 1; i < arr.length; i++) {
            var key = arr[i];
            var j = i - 1;
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
        return arr;
}

原理：希爾排序在插入排序的基礎(chǔ)上，將數(shù)據(jù)進(jìn)行了分組，將原有的數(shù)據(jù)分為若干個(gè)子集，然后對每個(gè)子集進(jìn)行排序，依次類推，不停地分割成子集，直到最后完全排序。

function shellSort(arr) {
    var len = arr.length,
        temp,
        gap = 1;
    while(gap < len/3) {          //動(dòng)態(tài)定義間隔序列
        gap = gap*3+1;
    }
    for (gap; gap > 0; gap = Math.floor(gap/3)) {
        for (var i = gap; i < len; i++) {
            temp = arr[i];
            for (var j = i-gap; j >= 0 && arr[j] > temp; j -= gap) {
                arr[j+gap] = arr[j];
            }
            arr[j+gap] = temp;
        }
    }
    return arr;
}