javascript排序算法

最新推荐文章于 2024-09-20 19:40:22 发布

UaoSonic

最新推荐文章于 2024-09-20 19:40:22 发布

阅读量228

点赞数 3

分类专栏：数据结构文章标签：数据结构排序 javascript

本文链接：https://blog.csdn.net/sunhl951/article/details/88737810

版权

数据结构专栏收录该内容

2 篇文章 0 订阅

订阅专栏

冒泡排序

//冒泡排序
var dataStore = [1,0,3,3,5,4,5,0,6,7];
function bubbleSort(arr) {
    var len = arr.length;
    for (var i = 0; i < len - 1; i++) {
        for (var j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j+1]) {        // 相邻元素两两对比
                var temp = arr[j+1];        // 元素交换
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}
console.log(bubbleSort(dataStore));

平均时间复杂度为 $O(n^{2})$ ，最好情况下为 O(n) ，最坏情况下为 $O(n^{2})$ ，空间复杂度为 O(1) ，是稳定的排序算法。

直接插入排序

//直接插入排序
var dataStore = [8,6,2,3,9,4,6];
var temp, j;
for(var i = 1; i<dataStore.length; i++){
    temp = dataStore[i];
    j=i;
    while(temp <= dataStore[j-1] && j>0){
        dataStore[j] = dataStore[j-1];
        j--;
    }
    dataStore[j] = temp;
}
console.log(dataStore);

平均时间复杂度为 $O(n^{2})$ ，最好情况下为 O(n) ，最坏情况下为 $O(n^{2})$ ，空间复杂度为 O(1) ，是稳定的排序算法。

简单选择排序

var dataStore = [8,6,2,3,9,4,6];
var k,temp;
for (var i=0;i<dataStore.length-1;i++){
    k=i;
    for(var j=i+1;j<dataStore.length;j++){
        if(dataStore[j]<dataStore[k]){
            k=j;
        }
    }
    if(i!=k){
        temp = dataStore[k];
        dataStore[k] = dataStore[i];
        dataStore[i] = temp;
    }
    
}
console.log(dataStore);

平均时间复杂度为 $O(n^{2})$ ，最好情况下为 $O(n^{2})$ ，最坏情况下为 $O(n^{2})$ ，空间复杂度为 O(1) ，是不稳定的排序算法。

堆排序

//堆排序
function filterDown(arr,start,end){
    var i = start;
    var j = i*2+1;
    temp = arr[i];
    while(j<end){
        if((j<end-1)&&(arr[j]<arr[j+1])){
            j++
        }
        if(temp<arr[j]){
            arr[i]=arr[j];
            i=j;
            j*=2;
        }
        else break;
        arr[i] = temp;
    }
}

function heapSort(arr){
    for(var i = Math.floor(arr.length/2)-1;i>=0;i--){
        filterDown(arr,i,arr.length);
    }
    for(var i = arr.length-1;i>0;i--){
        temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        filterDown(arr,0,i-1);
    }
}

var dataStore = [8,6,2,3,9,4,6];
heapSort(dataStore);
console.log(dataStore);

平均时间复杂度为 $O(nlog_{2}n)$ ，最好情况为 $O(nlog_{2}n)$ ，最坏情况为 $O(nlog_{2}n)$ ，空间复杂度为 O(1) ，是不稳定的排序算法。

归并排序

//归并排序
function mergeArrays(arr, startLeft, stopLeft, startRight, stopRight){
    var leftArr = new Array(stopLeft-startLeft+1);
    var rightArr = new Array(stopRight-startRight+1);
    var mid;
    mid = startLeft;
    for(var i=0;i<(leftArr.length-1);i++){
        leftArr[i] = arr[mid];
        mid++;
    }
    mid = startRight;
    for(var i=0;i<(rightArr.length-1);i++){
        rightArr[i] = arr[mid];
        mid++;
    }
    rightArr[rightArr.length-1] = Infinity;
    leftArr[leftArr.length-1] = Infinity;
    var m = 0;
    var n = 0;
    for(var k = startLeft;k<stopRight;k++){
        if(leftArr[m] <= rightArr[n]){
            arr[k] = leftArr[m];
            m++;
        }
        else{
            arr[k] = rightArr[n];
            n++;
        }
    }
}

function mergeSort(arr){
    if(arr.length<2){
        return;
    }
    var step = 1;
    var left,right;
    while(step<arr.length){
        left = 0;
        right = step;
        while(right+step<=arr.length){
            mergeArrays(arr,left,left+step,right,right+step);
            left = right+step;
            right = left+step;
        }
        if(right<arr.length){
            mergeArrays(arr,left,left+step,right,arr.length);
        }
        step *=2;
    }
}

var dataStore = [8,6,2,3,9,4,6];
mergeSort(dataStore);
console.log(dataStore);

平均时间复杂度为 $O(nlog_{2}n)$ ，最好情况为 $O(nlog_{2}n)$ ，最坏情况为 $O(nlog_{2}n)$ ，空间复杂度为 O(1) ，是稳定的排序算法。

快速排序

//快速排序
function qSort(arr){
    if(arr.length == 0){
        return [];
    }
    var left = [];
    var right = [];
    var pivot = arr[0];
    for(var i=1;i<arr.length;i++){
        if(arr[i]<pivot){
            left.push(arr[i]);
        }
        else{
            right.push(arr[i]);
        }
    }
    return qSort(left).concat(pivot,qSort(right));
}
var dataStore = [8,6,2,3,9,4,6];
console.log(qSort(dataStore));

平均时间复杂度为 $O(nlog_{2}n)$ ，最好情况为 $O(nlog_{2}n)$ ，最坏情况为 $O(n^{2})$ ，空间复杂度为 $O(nlog_{2}n)$ ，是不稳定的排序算法。

希尔排序（shell排序）

//希尔排序
var temp;
var dataStore = [8,6,2,3,9,4,6];
var d = Math.floor(dataStore.length/2);
var j;
while(d>=1){
    for(var i=d;i<dataStore.length;i++){
        temp = dataStore[i];
        j = i-d;
        while(j>=0&&temp<dataStore[j]){
            dataStore[j+d] = dataStore[j];
            j=j-d;
        }
        dataStore[j+d] = temp;
    }
    d=Math.floor(d/2);
}
console.log(dataStore);

平均时间复杂度为 $O(n^{1.3})$ ，最好情况为 O(n) ，最坏情况为 $O(n^{2})$ ，空间复杂度为 O(1) ，是不稳定的排序算法。