数据结构:JavaScript实现各种排序

这里首先写了一个数组测试平台，用于生成随机的数组进行排序的测试

function CArray(numElements){
  this.dataStore = [];
  this.pos = 0;
  this.numElements = numElements;
  this.insert = insert;
  this.toString = toString;
  this.clear = clear;
  this.setData  = setData;
  this.swap = swap;
  for(var i = 0; i < numElements; i++){
    this.dataStore[i] = i;
  }
  //冒泡排序
  this.bubbleSort = bubbleSort;
  //选择排序
  this.selectionSort = selectionSort;
  //插入排序
  this.insertSort = insertSort;
  //希尔排序
  this.shellSort = shellSort;
}


function setData(){
  for(var i = 0; i < this.numElements; i++){
    this.dataStore[i] = Math.floor(Math.random() * (this.numElements + 1));
  }
}


function clear(){
  for(var i = 0; i < this.dataStore.length; i++){
    this.dataStore[i] = 0;
  }
}


function insert(element){
  this.dataStore[this.pos++] = element;
}


function toString(){
  var restr = "";
  for(var i = 0; i < this.dataStore.length; i++){
    restr += this.dataStore[i] + " ";
    if(i > 0 && i % 10 === 9){
      restr += "\n";
    }
  }
  return restr;
}


function swap(arr, index1, index2){
  var temp = arr[index1];
  arr[index1] = arr[index2];
  arr[index2] = temp;
}

var numElements = 10;
var myNums = new CArray(numElements);
myNums.setData();
console.log(myNums.toString());

这样即可生成随机的长度为十的数组

一.冒泡排序

冒泡排序是一种比较容易实现的排序算法，之所以叫做冒泡，是因为在使用冒泡排序时，数值会像气泡一样从数组的一端漂浮到另一端，假设正在将一组数字按照升序排列，较大的值会浮动向数组的右侧，而较小的值会浮动向数组的左侧，出现这样的现象是因为算法会在数组中移动，比较相邻的数据，当左侧的值大于右侧的值时，将这两个数据的值进行交换，这里就用到了swap函数

代码如下

/冒泡排序
function bubbleSort(){
  var numElements = this.dataStore.length;
  var temp;
  for(var outer = numElements; outer >= 2; outer--){
    for(var inner = 0; inner <= outer - 1; inner++){
      if(this.dataStore[inner] > this.dataStore[inner + 1]){
        swap(this.dataStore, inner, inner + 1);
      }
    }
    //用于看清每次排序后数组的变化情况
    console.log(myNums.toString());
  }
}

调用函数

var numElements = 10;
var myNums = new CArray(numElements);
myNums.setData();
console.log(myNums.toString());
myNums.bubbleSort();
console.log(myNums.toString());

运行结果

二.选择排序

选择排序从数组的第一个元素开始，假设第一个数据是最小的，将该元素依次和其他元素进行比较，检查完所有元素之后，最小的元素将会被放在第一位，然后算法会从第二个元素开始重复以上动作，这样一直继续下去，直到进行到数组的倒数第二个元素位置，所有的元素已经完成了排序。

代码如下

</pre><pre name="code" class="javascript">//选择排序
function selectionSort(){
  var min, temp;
  for(var outer = 0; outer <= this.dataStore.length - 2; outer++){
    min = outer;
    for(var inner = outer + 1; inner <= this.dataStore.length - 1; inner++){
      if(this.dataStore[inner] < this.dataStore[min]){
        min = inner;
      }
      swap(this.dataStore, outer, min);
    }
    console.log(myNums.toString());
  }
}

调用函数

var numElements = 10;
var myNums = new CArray(numElements);
myNums.setData();
console.log(myNums.toString());
myNums.selectionSort();
console.log(myNums.toString());

运行结果

三.插入排序

每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

插入排序并非是通过数据交换，而是通过将较大的元素向右移动，为数组左侧的较小元素腾出位置。

代码如下

//插入排序
function insertSort(){
  var temp, inner;
  for(var outer = 1; outer <= this.dataStore.length - 1; outer++){
    temp = this.dataStore[outer];
    inner = outer;
    while(inner > 0 && (this.dataStore[inner - 1] >= temp)){
      this.dataStore[inner] = this.dataStore[inner - 1];
      inner--;
    }
    this.dataStore[inner] = temp;
    console.log(myNums.toString());
  }
}

调用函数

var numElements = 10;
var myNums = new CArray(numElements);
myNums.setData();
console.log(myNums.toString());
myNums.insertSort();
console.log(myNums.toString());

运行结果

四.希尔排序

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

计算动态间隔序列

在这里通过一个公式来对希尔排序用到的间隔序列进行动态计算，首先是计算初始间隔值

var N = this.dataStore.length;
  var h = 1;
  while(h < N / 3){
    h = 3 * h + 1;
  }

完整代码如下

//希尔排序
function shellSort(){
  var N = this.dataStore.length;
  var h = 1;
  while(h < N / 3){
    h = 3 * h + 1;
  }
  while (h >= 1) {
    for(var i = h; i < N; i++){
      for(var j = i; j >= h && this.dataStore[j] < this.dataStore[j - h]; j -= h){
        swap(this.dataStore, j, j - h);
      }
    }
    h = (h - 1)/3;
    console.log(myNums.toString());
  }
}

调用函数

var numElements = 20;
var myNums = new CArray(numElements);
myNums.setData();
console.log("shell排序前\n");
console.log(myNums.toString());
console.log("shell排序中\n");
myNums.shellSort();
console.log("shell排序后\n");
console.log(myNums.toString());

运行结果

五.快速排序

快速排序是处理大数据集最快的排序算法之一。它是一种分而治之的算法，通过递归的方式将数据依次分解为包含较小元素和较大元素的两个子序列，然后不断重复这个步骤，直到所有数据都是有序的。

首先需要选定一个基准值，将小于基准值的元素放在基准值之前，大于基准值的元素放在基准值之后。

代码如下

//快速排序
function qSort(list){
  if(list.length === 0){
    return [];
  }
  var lesser = [];
  var greater = [];
  var pivot = list[0];
  for(var i = 1; i < list.length; i++){
    if(list[i] < pivot){
      lesser.push(list[i]);
    }else{
      greater.push(list[i]);
    }
  }
  return qSort(lesser).concat(pivot, qSort(greater));
}

调用函数

var myArray = [1, 30, 0, 4, 8, 2, 5];
console.log(myArray);
var newArray = qSort(myArray);
console.log(newArray);

运行结果