javascript数据结构与算法--高级排序算法

javascript数据结构与算法--高级排序算法

     高级排序算法是处理大型数据集的最高效排序算法，它是处理的数据集能够达到上百万个元素，而不单单是几百个或者几千个。如今咱们来学习下2种高级排序算法---- 希尔排序和快速排序。

一：希尔排序；

希尔排序的核心理念是：首先比较距离较远的元素，而非相邻的元素。

基本原理：经过定义一个间隔序列来表示在排序过程当中进行比较的元素之间有多远的间隔。

下面咱们来看看数组[0,9,1,8,7,6,2,3,5,4] 来使用希尔排序的原理；以下图：

 

代码分析以下：

1. 执行 "间隔序列=3的步骤"

    A. 那么第一次执行 "间隔序列=3" 的步骤，那么找到位置间隔3的元素为 0 ,  8  , 2  , 4

        因此这四个数字当中0最小，因此位置不动，仍是第一个位置，8是最大的 因此位置就移动到以前的4的位置上，4移动到8的位置上，可是2和4比较 2小          于4的 因此2和4位置继续调换。因此如今的顺序为0 , 2 , 4  , 8，如上图(间隔序列=3)

   B. 如今第二次执行 "间隔序列=3" 的步骤，找到元素为 9 , 7 , 3 分析仍是和上面的同样 3是最小的，因此移动到原先9的位置上，9就移到到3的位置上，   由     于7小于9 因此不须要移动，因此如今的顺序为 3 , 7 , 9 如上图(间隔序列=3)

  C. 如今第三次执行 "间隔序列=3"的步骤，找到元素 1 , 6 , 5 ,因为1是最小的 因此不须要移动，6大于5，因此2者要调换位置 因此顺序为 1 , 5  , 6

      执行完上面的步骤后，正确的顺序为 [0,3,1,2,7,5,4,9,6,8]

2. 执行 "间隔序列=2"的步骤

   A. 第一次查找 找到元素 0,1,7,4,6,因此原理仍是和上面同样，0和1不须要移动 7和4及6调换位置，所以如今的顺序变为 0,1,4,6,7

   B. 第二次查找 找到元素 3,2,5,9,8 ，因此顺序变为 2,3,5,8,9

 执行完上面的步骤后，正确的顺序为 [0,2,1,3,4,5,6,8,7,9] 如上图(间隔序列=2)

3. 执行 "间隔序列=1"的步骤；

     数组的顺序就变为 [0,1,2,3,4,5,6,7,8,9].如上图(间隔序列=1)

JS代码以下：

function CArray(numElements,gaps) {
    this.dataStore = [];
    this.pos = 0;
    this.numElements = numElements;
    this.gaps = gaps;
    this.insert = insert;
    this.toString = toString;
    this.clear = clear;
    this.shellSort = shellSort;
    for(var i = 0; i < numElements.length; i++) {
        this.dataStore[i] = numElements[i];
    }            
}
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 == 0) {
            restr+= "\n";
        }
    }
    return restr;
}
        
function shellSort() {
    for(var g = 0; g < this.gaps.length; ++g) {
        for(var i = this.gaps[g]; i < this.dataStore.length; ++i) {
            var temp = this.dataStore[i];
            for(var j = i; j >= this.gaps[g] && this.dataStore[j - this.gaps[g]] > temp; j -= this.gaps[g]) {
                this.dataStore[j] = this.dataStore[j - this.gaps[g]];
            }
            this.dataStore[j] = temp;
        }
    }
}
// 希尔排序测试代码
var numElements = [0,9,1,8,7,6,2,3,5,4];
var gaps = [3,2,1];
var myNums = new CArray(numElements,gaps);
myNums.shellSort();
console.log(myNums.toString());

二：快速排序

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

这个算法首先要在列表中选择一个元素来做为基准值，数据排序围绕基准值进行，将列表中小于基准值的元素移动到数组的左边，将大于基准值的元素移动到数组的右边，以下图所示：

 

基本原理是：

1. 选择一个基准元素，将列表分割成2个子序列。基准元素的选择能够有3种方式，能够选择第一个元素做为基准元素，也能够把中间的值做为基准元素，还能够把最后一个元素做为基准的元素。
2. 对列表从新排序，将全部小于基准值的元素放在基准值的前面，全部大于基准值的元素放在基准值的后面。
3. 分别对较小元素的子序列和较大元素的子序列的重复步骤1和2.

下面是JS的代码以下：

// 快速排序
function qSort(list) {
    if(list.length == 0) {
        return [];
    }
    // 存储小于基准值的值
    var left = [];
    // 存储大于基准值的值
    var right = [];
    var pivot = list[0];
    for(var i = 1; i < list.length; i++) {
        if(list[i] < pivot) {
            left.push(list[i]);
        }else {
            right.push(list[i])
        }
    }
    return qSort(left).concat(pivot,qSort(right));
}
// 快速排序测试代码
var numElements = [44,75,23,43,55,12,64,77,33];
var list = qSort(numElements);
console.log(list);  // [12, 23, 33, 43, 44, 55, 64, 75, 77]