js-排序算法

之前和一个小伙伴谈起了排序算法，所以我抽时间整理了大家平时常见的一些排序算法。

1、冒泡算法：

  <script>
        function sortMP(ele) {
            for (var i = 0; i < ele.length - 1; i++) {
                for (j = 0; j < ele.length - i - 1; j++) {
                    if (ele[j] > ele[j + 1]) {
                        var swap = ele[j];
                        ele[j] = ele[j + 1];
                        ele[j + 1] = swap;
                    }
                }
            }
           return ele;
        }
        var ele = [3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
        console.log(sortMP(ele));
    </script>

冒泡排序动图演示

2、选择排序：

  <script>
        function selectSort(arr) {
            var len = arr.length;
            var minIndex, temp;
            console.time('选择排序耗时');
            for (var i = 0; i < len; i++) {
                minIndex = i;
                for (var j = i + 1; j < len; j++) {
                    if (arr[j] < arr[minIndex]) { //寻找最小的数
                        minIndex = j; //将最小的数的索引进行保存
                    }
                }
                temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
            console.timeEnd('选择排序耗时');
            return arr;
        }
        var arr = [3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
        console.log(selectSort(arr));
    </script>

选择排序动图演示

3、插入排序：

    <script>
        function sortCR(ele) {
            //假设第0个元素是一个有序的数列，第1个以后的是无序的序列
            //所以从第一个元素开始将无序数列的元素插入到有序数列中
            for (var i = 1; i < ele.length; i++) {
                if (ele[i] < ele[i - 1]) {
                    //取出无序数列中的第i个作为被插入元素
                    var guard = ele[i];
                    //记住有序数列的最后一个位置，并且将有序数列位置扩大一个
                    var j = i - 1;
                    ele[i] = ele[j];
                    //比大小，找出被插入元素所在的位置
                    while (j >= 0 && guard < ele[j]) {
                        ele[j + 1] = ele[j];
                        j--;
                    }
                    ele[j + 1] = guard; //插入
                }
            }
　　　　　　　return ele;
        }
        var ele = [3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
        console.log(sortCR(ele));
    </script>

插入排序动图演示

4、快速排序：

    <script>
        function quickSort(ele) {
            if (ele.length <= 1) {
                return ele;
            }
            var privotIndex = Math.floor(ele.length / 2);
            // alert(ele.length);
            var privot = ele.splice(privotIndex, 1)[0];
            //alert(privot);
            var left = [];
            var right = [];
            for (var i = 0; i < ele.length; i++) {
                if (ele[i] <= privot) {
                    left.push(ele[i]);
                } else {
                    right.push(ele[i]);
                }
            }
            return quickSort(left).concat([privot], quickSort(right));
        }
        var ele =  [3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
        console.log(quickSort(ele));
    </script>

快速排序动图演示

5、希尔排序：

 <script>
        //希尔排序实际上是分组插入排序，该方法又称速效增量排序
        function shallSort(arr) {
            var increment = arr.length;
            var i;
            var temp;
            var count = 0;
            do {
                //设置增量
                increment = Math.floor(increment / 3) + 1;
                for (i = increment; i < arr.length; i++) {
                    console.log(increment);
                    if (arr[i] < arr[i - increment]) {
                        temp = arr[i];
                        for (var j = i - increment;j >= 0 && temp < arr[j];j -= increment){
                            arr[j + increment] = arr[j];
                        }
                        arr[j + increment] = temp;
                    }
                }
            }
            while (increment > 1)
            return arr;
        }
        var ele = [4, 2, 1, 3, 7, 9, 6];
        console.log(shallSort(ele));
    </script>