Question

这是数组：

var ar = [1,2,7,3];

要对它进行排序，必须在上部循环中进行3次迭代，在内部循环中进行3,2,1次迭代。所以我写了一个算法来做到这一点：

function sort() {
    var i,j;
    for (i=1; i < ar.length; i++) {
        for (j=0; j < ar.length - i; j++) {
            if (ar[j] > ar[j+1]) {
                ar.swap(j, j+1);
            }
        }
    }
}

然后我检查了实施here：

function bubbleSort(items){

    var len = items.length,
        i, j, stop;

    for (i=0; i < len; i++){
        for (j=0, stop=len-i; j < stop; j++){
            if (items[j] > items[j+1]){
                items.swap(j, j+1);
            }
        }
    }

    return items;
}

现在，该算法在上部循环中有4次迭代，在给定数组的内部循环中有4,3,2,1次迭代。我不明白为什么会这样，我错过了什么？

Answer 1

这里是一个优化的冒泡排序 - 它最有效率 - 在最差的情况下 - 但是更接近原始数组的排序是

function swap(a, i, j, t) { // dirty hack for swap
    t = a[i];
    a[i] = a [j];
    a[j] = t;
}
function bubbleSortOptimized(items) {
    var newn, i, n = items.length;
    do {
        newn = 0
        for(i = 1; i < n; i+=1) {
            if (items[i-1] > items[i]) {
                swap(items, i-1, i);
                newn = i;
            }
        }
        n = newn
    }
    while(n);
    return items;
}

顺便说一句，数组上没有交换方法 - 不确定你的代码是如何运行的

Answer 2

基本上optimized Bubble Sort是在当前迭代中没有交换时停止，因为它会在那个时间完全排序，在最好的情况下（已排序）将产生O(n)时间复杂度，可以这样写：

Demo

function bubbleSort(items)
{
    var len = items.length, i, j, t;
    var swaps = 0;

    for (i=0; i < len; i++)
    {
        swaps = 0;

        for (j=0; j < len-i; j++)
        {
            if (items[j] > items[j+1])
            {
                t = items[j];
                items[j] = items[j+1];
                items[j+1] = t;

                swaps++;
            }
        }

        // stop when there were no swaps in current iteration
        if (swaps === 0) break;
    }

    return items;
}

冒泡排序 - 为什么需要额外的循环

2 个答案: