JavaScript(js)的四种常见排序的实现

常见排序 冒泡排序 快速排序(递归排序) 选择性排序 插入排序

冒泡排序 bubbleSort

冒泡排序通过相邻数据元素的交换，逐步将待排序序列变为有序序列，如果前面的数据大于后面的数据，就将两值进行交换，将数据进行从小到大的排序，这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就到了数组第N-1个位置，排序进行完成。

var arr = [1, 9, 4, 2, 5, 3, 8, 6, 7, 1, 3, 5];
    function bubbleSort(array) {
        if (Array.isArray(array)) {
            if (array.length == 1) {
                return array;
            }
            var temp = null;
            for (var i = 0; i < array.length; i++) {
                for (var j = 0; j < array.length - i - 1; j++) {
                    if (array[j] > array[j + 1]) {
                        temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
            }
            return array;
        }
    }
    console.log(bubbleSort(arr));
 

快速排序（递归排序）quickSort

先从数列中取出一个数作为基准数,分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边,再对左右区间重复第二步，直到各区间只有一个数。

 var arrinfo = [1, 9, 4, 2, 5, 3, 8, 6, 7, 1, 3, 5];
    function quickSort(array) {
        if (Array.isArray(array)) {
            if (array.length <= 1) {
                return array;
            }
            var centerIndex = Math.ceil(array.length / 2);
            var cValue = array.splice(centerIndex, 1);
            var left = [];
            var right = [];
            //开始对剩余的值比较  左右添加
            array.forEach(function (value) {
                if (value > cValue) {
                    left.push(value);
                }
                else {
                    right.push(value);
                }
            });
            //递归
            return quickSort(left).concat(cValue, quickSort(right));
        }
    }
    console.log(quickSort(arrinfo));

选择法排序

第1趟，在待排序记录r[1] ~ r[n]中选出最小的记录，将它与r[1]交换;第2趟，在待排序记录 r[2] ~ r[n]中选出最小的记录，将它与r[2]交换;以此类推,第i趟在待排序记录r[i] ~ r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕。

function selectSort(array) {
        if (Array.isArray(array)) {
            if (array.length == 1) {
                return array;
            }
            for (var i = 0; i < array.length - 1; i++) {
                var minIndex = i;//默认当前的i最小
                for (var j = i + 1; j < array.length; j++) {
                    minIndex = array[minIndex] < array[j] ? j : minIndex;
                }
                //交换位置
                [array[i],array[minIndex]]=[array[minIndex], array[i]];
            }
            return array;
        }
    }
    var arrinfo = [1, 9, 4, 2, 5, 3, 8, 6, 7];
    console.log(selectSort(arrinfo));

插入排序

1. 从第一个元素开始，该元素可以认为已经被排序
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5.将新元素插入到下一位置中
6.重复步骤2

var arrdata = [1, 9, 4, 2, 5, 3, 8, 6, 7];
    function insertSort(arr) {
        if (Array.isArray(arr)) {
            if (arr.length == 1) {
                return arr;
            }
            //插入排序
            for (var i = 1; i < arr.length; i++) {
                var current = arr[i];//当前值
                var preIndex = i - 1;
                //开始向左找
                while (preIndex >= 0 && arr[preIndex] < current) {
                    arr[preIndex + 1] = arr[preIndex];
                    preIndex--;
                }
                arr[preIndex + 1] = current;
            }
            return arr;
        }
    }
    console.log(insertSort(arrdata));