數據結構與算法--排序(JS實現)

前言

  複習數據結構的時候發現都是以JAVA爲例，雖然JS的算法用的比較少，不少時候基本上也用不到。但仍是趁有空折騰一下吧，主要實現內排序的算法。

排序分類

根據排序過程當中藉助的主要操做，咱們將內排序分爲： 插入排序類：直接插入排序，希爾排序 選擇排序類：簡單選擇排序，堆排序 交換排序類：冒泡排序，快速排序 歸併排序類：歸併排序

---

直接插入排序

基本思想

將一個記錄插入到已經排好序的有序表中，從而獲得一個新的，記錄數增1的有序表

代碼實現

function insertSort(data){
  var temp;
  for (var i = 1; i < data.length; i++) {
    temp = data[i];
    if(data[i] < data[i-1]){
      for (var j = i-1; data[j] > temp; j--) {
        data[j+1] = data[j];
      };
      data[j+1] = temp;
    }
  };
  return data;
}
複製代碼

---

希爾排序

基本思想

將相距某個「增量」的記錄組成一個子序列，這樣才能保證在子序列內分別進行直接插入排序後獲得的結果是基本序列而不是局部有序 (*基本系列：就是小的關鍵字基本在前面，大的基本在後面，不大不小的基本在中間)

代碼實現

function shellSort(data){
  var increment = data.length;
  var temp;
  do{
    increment =  Math.floor(increment/3)+1;
    for (var i = increment; i < data.length; i++) {
      if (data[i] < data[i-increment]) {
        temp = data[i];
        for (var j = i-increment; temp<data[j]; j-=increment) {
          data[j+increment] = data[j];
        };
        data[j+increment] = temp;
      };
    };
    console.log(data);
  }
  while(increment>1);
  return data;
}
複製代碼

---

簡單選擇排序

基本思想

經過n-1次關鍵字簡的比較，從n-i+1個記錄中選出關鍵字最小的記錄，並和第i(i《i《n)個記錄換之

代碼實現

function selectSort(data){
  var min;
  for (var i = 0; i < data.length; i++) {
    min = i;
    for (var j = i+1; j < data.length; j++) {
      if (data[min] > data[j]) {
        min = j;
      };
    };  
    if ( i!= min) {
      swap(data,i,min);
    };
  };
  return data;
}
複製代碼

---

堆排序

基本思想

將待排序的序列構形成一個大頂堆。此時，整個序列的最大值就是堆頂的根節點。將它移走，而後將剩餘n-1個序列從新構形成一個堆，這樣就會獲得n個元素中的次大值。如此反覆執行，便能獲得一個有序序列了。

代碼實現

function heapSort (data) {
  for (var i = Math.floor(data.length/2); i >= 0; i--) {
    data = heapAdjust(data, i, data.length-1)
  };
  for(var i = data.length-1;i>0;i--){
    swap(data, 0, i);
  
    data = heapAdjust(data, 0, i-1);
  }
  return data;
}
//構造大頂堆
function heapAdjust(data, s, m){
  var temp = data[s];
  for (var j = (2*s+1); j <= m; j=j*2+1){
    if (j<m && data[j]<data[j+1]) {
      ++j;
    };
    if (temp >= data[j]) {
      break;
    };
    data[s] = data[j];
    s = j;
  };
  data[s] = temp;
  return data;
}
複製代碼

---

冒泡排序

基本思想

兩兩比較相鄰記錄的關鍵字，若是反序則交換

代碼實現

function bubbleSort(data){
  var flag = true;
  for (var i = 0; i < data.length && flag; i++) {
    flag = false;
    for (var j = data.length; j >= i; j--) { //注意！！！j是從後往前
      if (data[j] <= data[i]) {
        swap(data,i,j);
        flag = true;
      };
    };
  };
  return data;
};

function swap(arr, i ,j){
  var temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
}
複製代碼

---

快速排序

基本思想

經過同樣排序將待排記錄分割成獨立的兩部分，其中一部分記錄的關鍵字均比另外一部分的關鍵字小，則可分別對這兩部分記錄繼續進行排序，以達到整個序列有序的目的

代碼實現

function quickSort(data){
  return QSort(data,0,data.length-1);
}
function QSort(data, low, high){
  var pivot; //樞軸值
  if (low<high) {
    pivot = partition(data, low, high);

    QSort(data, low, pivot-1);
    QSort(data, pivot+1, high);
  };
  return data;
}
function partition(data, low, high){
  var pivotkey = data[low];
  while(low<high){
    while(low<high && data[high] >= pivotkey){
      high--;
    }
    swap(data,low,high);
    while(low<high && data[low]<=pivotkey){
      low++;
    }
    swap(data,low,high);
  }
  return low;
}
複製代碼