Javascript数据结构---排序

排序

---

排序效率： 希尔(动态规划希尔) 选择 冒泡 插入
算法都在一个数组中定义

（一）冒泡排序

//冒泡排序
function bubbleSort() {
    for(var outer = this.numElements; outer >= 2; outer--) {
        var flag = true;
        for(var inner = 0; inner < outer-1; inner++) {
            if (this.dataStore[inner] > this.dataStore[inner+1]) {
                swap(this.dataStore, inner, inner+1);
                //每一步排序结果打印
                flag = false;
            }
        }
        if (flag) {
            break;
        }
    }
}

（二）选择排序

//选择排序
function selectionSort() {
    for(var outer = 0; outer < this.numElements-1; outer++) {
        var min = outer,
                flag = false;
        for(var inner = outer+1; inner < this.numElements; inner++) {
            if (this.dataStore[min] > this.dataStore[inner]) {
                min = inner;
                flag = true;
            }
        }
        if (flag) {
            swap(this.dataStore, outer, min);
            //每步排序结果打印
        }
    }
}

（三）插入排序

function insertSort() {
    var temp, inner;
    for(var outer=1; outer<this.numElements; outer++) {
        temp = this.dataStore[outer];
        inner = outer;
        while((this.dataStore[inner-1] >= temp) && inner>0) {
            this.dataStore[inner] = this.dataStore[inner-1];
            inner--;
        }
        this.dataStore[inner] = temp;
        //排序过程
    }
}

（四）希尔排序

function shellSort() {
    for(var i=0; i<this.gaps.length; i++) {
        for(var j=this.gaps[i]; j<this.numElements; j++) {
            var temp = this.dataStore[j];
            for(var k=j; k>=this.gaps[i] && temp<this.dataStore[k-this.gaps[i]];
             k-=this.gaps[i]) {
                this.dataStore[k] = this.dataStore[k-this.gaps[i]];
            }
            this.dataStore[k] = temp;
        }
    }
}

（五）动态规划计算间隔的希尔排序

//动态计算间隔的希尔排序
function shellSort1() {
    var n = this.numElements;
    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;
    }
}

（六）快速排序

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