数据结构与算法--排序(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;
}
复制代码