js实现希尔排序

希尔排序

希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法，希尔排序也是一种插入排序，他是简单插入排序经过改进后的一个更高效的版本，也称为缩小增量排序。

基本思想

思想是指定一个间隔（增量）将待排序的元素进行分组，然后再对每一组进行排序，直到间隔（增量）减至1时，整个序列恰好被分成一组，最后排成有序序列

动画演示

逐步推导过程

let arr = [9,5,8,7,1,4,6,3,2,0];
// shell排序
function shellSort(arr){
    // 10个需要数据进行三轮交换排序
    // 第一轮排序将10个数据分成了5组
    for(let i=5;i<arr.length;i++){
        // 遍历各组中所有的元素,共有5组,每组2个元素,步长为5
        for(let j = i-5;j >= 0;j -= 5){
            //如果当前元素大于加上步长后的那个元素,则交换(从小到大排序)
            if(arr[j] > arr[j+5]){
                let tmp = arr[j];
                arr[j] = arr[j+5];
                arr[j+5] = tmp;
            }
        }
    }
    // 第一轮排序后输出[ 4, 5, 3, 2, 0, 9, 6, 8, 7, 1 ]

    // 第二轮排序将10个数据分成了5/2 = 2组
    for(let i=2;i<arr.length;i++){
        for(let j = i-2;j >= 0;j -= 2){
            //如果当前元素大于加上步长后的那个元素,则交换(从小到大排序)
            if(arr[j] > arr[j+2]){
                let tmp = arr[j];
                arr[j] = arr[j+2];
                arr[j+2] = tmp;
            }
        }
    }
    //第二轮排序后输出[ 0, 1, 3, 2, 4, 5, 6, 8, 7, 9 ]

    // 最后一轮排序将10个数据分成了2/2 = 1组
    for(let i=1;i<arr.length;i++){
        for(let j = i-1;j >= 0;j -= 1){
            //如果当前元素大于加上步长后的那个元素,则交换(从小到大排序)
            if(arr[j] > arr[j+1]){
                let tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        }
    }
    //最后一轮输出[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
    return arr;
}
console.log(shellSort(arr));

得到初步算法

• 该算法（交换法）的思想虽然较好，但是效率比直接插入排序要低

let arr = [9,5,8,7,1,4,6,3,2,0];
function shellSort(arr){
    let tmp = 0;
    for(let gap = arr.length / 2;gap > 0;gap =Math.floor( gap/2)){
        for(let i=gap;i<arr.length;i++){
            for(let j = i - gap;j >= 0;j -= gap){
                if(arr[j] > arr[j+gap]){
                    tmp = arr[j];
                    arr[j] = arr[j+gap];
                    arr[j+gap] = tmp;
                }
            }
        }
    }
    return arr;
}
console.log(shellSort(arr));

优化成移位法

let arr = [];
for(let i=0;i<5000000;i++){
    let tmp = Math.floor(Math.random() * 5000000);
    arr.push(tmp)
}
const t1 = new Date();
var time1 = t1.getTime();
function shellSort(arr){
    for(let gap = Math.floor(arr.length/2);gap > 0;gap = Math.floor(gap/2)){
        for(let i = gap;i < arr.length;i++){
            let j = i;
            let tmp = arr[j];
            if(arr[j] < arr[j-gap]){
                // 如果同一组中 前数大于后数，则交换他们
                while(j - gap >= 0 && arr[j-gap] > tmp){
                    arr[j] = arr[j-gap];
                    j = j-gap;
                }
                arr[j] = tmp;
            }
        }
    }
    const t2 = new Date();
    console.log((t2.getTime() - time1)/1000+"秒");//2.186秒左右
    return arr;
}
shellSort(arr);

let arr = [];
for(let i=0;i<5000000;i++){
    arr.push(Math.random() * 5000000);
}
const t1 = new Date().getTime();

function shellSort(arr){
    for(let gap = Math.floor(arr.length/2);gap > 0;gap = Math.floor(gap/2)){
        for(let i = gap;i < arr.length;i++){
            let j = i;
            let tmp = arr[j];
            if(arr[j] < arr[j-gap]){
                while(j-gap >= 0 && tmp < arr[j-gap]){
                    arr[j] = arr[j-gap];
                    j = j-gap;
                }
            }
            arr[j] = tmp;
        }
    }
    const t2 = new Date().getTime();
    console.log((t2 -t1)/1000+'秒');//
    return arr
}
shellSort(arr);

时间复杂度

• (1) 最好情况：序列是正序排列，在这种情况下，需要进行的比较操作需（n-1）次。后移赋值操作为0次。即O(n)
• (2) 最坏情况：O(nlog2n)。
• (3) 渐进时间复杂度（平均时间复杂度）：O(nlog2n)