1.如何在陣列中間位置新增陣列

function avaerageAdd(){
  var nums = [1,2,3,4,5,6,7,8];
  var newElements = [233,666];
  nums.splice.apply(nums, [Math.floor(nums.length)/2, 0].concat(newElements));
  return nums // [1, 2, 3, 4, 233, 666, 5, 6, 7, 8];
}

2.判定給定字串是否迴文

迴文的意思是那麼以某個字元為中心的字首和字尾都是相同的.迴文的判斷非常簡單，就是利用堆疊的特性，把字串壓入堆疊，然後彈出，這樣順序就和原字串相反，再判斷字串是否和原字串相等即可。

function isPalindrome(word){
  var s = new Stack()
  for (var i = 0; i < word.length; ++i) {
     s.push(word[i])     
  }
  var rword = ""
  while(s.length() > 0){
    rword += s.pop()
  }
  if(word == rword){
    return true
  }else{
    return false
  }
}

var Stack = function() {
    this.dataStore = [];
    this.top = 0;
};
Stack.prototype.push = function(element) {
    this.dataStore.push(element);
};
Stack.prototype.pop = function() {
    return this.dataStore.pop();
};
Stack.prototype.peek = function() {
    return this.dataStore[this.dataStore.length - 1];
};
Stack.prototype.length = function() {
    return this.dataStore.length;
};
Stack.prototype.isEmpty = function() {
    return this.dataStore.length === 0;
};
Stack.prototype.seeAll = function() {
    return this.dataStore.join('\n');
};
 

3.氣泡排序

氣泡排序就是從最開始的位置或結尾的位置反方向對比，如果比它大/小,就交換然後繼續走，第一遍走完,最後一個位置是最大值或者最小值

function exchange(array, i, j) {
    var t = array[i];
    array[i] = array[j];
    array[j] = t;
}
function bubbleSort(numbers) {
    for (var i = 0; i < numbers.length; i++) {
        for (var j = 0; j < numbers.length - i; j++) {
            if (numbers[j] > numbers[j + 1]) {
                exchange(numbers, j, j + 1);
            }
        }
        console.log(numbers.toString());
    }
    return numbers;
}
var nums = [2,3,4,3,1,5,7,122,341,-1];
console.log(bubbleSort(nums));
 

快排就是一開始找個中介，然後把比它小的放左邊，比它大的放右邊，然後重新對中介兩邊的資料各自重新找個中介,如此迴圈。

function quickSort(arr) {
　　if (arr.length <= 1) { return arr }
     console.log("原陣列是:" + arr)
　　var pivotIndex = Math.floor(arr.length / 2)
　　var pivot = arr.splice(pivotIndex, 1)[0]
　　var left = []
　　var right = []
   console.log("將中介提取出來後陣列是:" + arr)
　　for (var i = 0 ; i < arr.length ; i++){
             console.log("此刻中介是:" + pivot + "當前元素是:" + arr[i])
　　　　if (arr[i] < pivot) {
　　　　　　left.push(arr[i])
                   console.log("移動" + arr[i] + "到左邊")
　　　　} else {
　　　　　right.push(arr[i])
                    console.log("移動" + arr[i] + "到右邊")
　　　　}
　　}
　　return quickSort(left).concat([pivot], quickSort(right))
}
var nums = [2,3,4,3,1,5,7,122,341,-1]
console.log(quickSort(nums))

5.選擇排序

找到陣列中最小的那個元素，將它和陣列的第一個元素交換位置，

如果第一個元素就是最小的那麼就和自己交換

然後，在剩下的陣列中找到最小的元素，將它和陣列的第二個元素交換

迴圈直到排序完成。

內迴圈只比較大小，交換程式碼在內迴圈之外

每次交換都排定一個元素，交換的總次數為N

function selectionSort(numbers) {
  for (var i = 0; i < numbers.length; i++) {
    var min = i;
    for (var j = i + 1; j < numbers.length; j++) {
      if (numbers[j] < numbers[min]) {
        min = j;
      }
    }
    if (i !== min) {
      exchange(numbers, i, min);
    }
  }
  return numbers;
}
var nums = [2,3,4,3,1,5,7,122,341,-1]
console.log(selectionSort(nums))

6.插入排序

插入排序它將陣列分成“已排序”和“未排序”兩部分，一開始的時候，“已排序”的部分只有一個元素，然後將它後面一個元素從“未排序”部分插入“已排序”部分，從而“已排序”部分增加一個元素，“未排序”部分減少一個元素。以此類推，完成全部排序。

function insertionSort(numbers) {
  console.log("原陣列:" + numbers)
  for (var i = 0; i < numbers.length; i++) {
        /*
         * 當已排序部分的當前元素大於value，
         * 就將當前元素向後移一位，再將前一位與value比較
         */
    for (var j = i; j > 0 && numbers[j] < numbers[j - 1]; j--) {
      // If the array is already sorted, we never enter this inner loop!
      exchange(numbers, j, j - 1);
      console.log("此時陣列:" + numbers);
    }
  }
return numbers;
};
var nums = [2,3,4,3,1,5,7,122,341,-1];
console.log(insertionSort(nums));

7.希爾排序

希爾排序屬於高階排序，因為它其實是利用了多個插入排序來實現。

先將整個待排序的記錄序列分割成為若干子序列分別進行直接插入排序，待整個序列中的記錄“基本有序”時，再對全體記錄進行依次直接插入排序

假設nums = [2,3,4,3,1,5,7,122,341,-1]

如果間隔為3，第一趟將陣列下標為 0,4,8 || 1,5,9 || 2,6,10 || 3,7, 分別取出來子序列內部進行排序

然後縮小間隔再排序直到間隔為1時,全部直接插入排序

function shellsort(numbers) {
  console.log("原陣列:" + numbers)
  var h = 1;
  while (h < numbers.length / 3) {
    h = (3 * h) + 1;
  }
  while (h >= 1) {
    console.log("此時h:" + h)
    for (var i = h; i < numbers.length; i++) {
      for (var j = i; j >= h && numbers[j] < numbers[j - h]; j -= h) {
        exchange(numbers, j, j - h);
        console.log("此時陣列:" + numbers);
      }
    }
    h = --h / 3;
  }
  return numbers;
}
var nums = [2,3,4,3,1,5,7,122,341,-1];
console.log(shellsort(nums));

8.歸併演算法

歸併演算法的原理是將所有元素拆成相鄰的一對一對的,然後兩兩排序,再將相鄰的一對元素再合併排序,四個四個排序,如此迴圈最後只剩兩組大的已經排好序的陣列再合併一起排序。

function mergeSort(numbers) {
    if (numbers.length < 2) {
        return numbers;
    }
    var middle = Math.floor(numbers.length / 2),
        left = numbers.slice(0, middle),
        right = numbers.slice(middle),
        params = merge(mergeSort(left), mergeSort(right));
    params.unshift(0, numbers.length);
    numbers.splice.apply(numbers, params);
    return numbers;
    function merge(left, right) {
        var result = [],
            il = 0,
            ir = 0;
        while (il < left.length && ir < right.length) {
            if (left[il] < right[ir]) {
                result.push(left[il++]);
            } else {
                result.push(right[ir++]);
            }
        }
        return result.concat(left.slice(il)) .concat(right.slice(ir));
    }
}
var nums = [2,3,4,3,1,5,7,122,341,-1]
console.log(mergeSort(nums))

9.二分搜尋

二分查詢是基本功，而且需要注意的是，二分查詢的前提是陣列一開始就是有序的。

function binSearch(arr, data) {
    arr = arr.sort(function(a, b) {
    return a - b;
  })
    console.log(arr)
  var upperBound = arr.length-1;
  var lowerBound = 0;
  while (lowerBound <= upperBound) {
    var mid = Math.floor((upperBound + lowerBound) / 2);
    console.log("Current midpoint: " + mid);
    if (arr[mid] < data) {
      lowerBound = mid + 1;
      }
    else if (arr[mid] > data) {
      upperBound = mid - 1;
      }
    else {
      return mid;
      }
    }
  return -1；
}
var nums = [2,3,4,3,1,5,7,122,341,-1]
console.log(binSearch(nums,122))