算法 - 冒泡排序、选择排序、快速排序

【冒泡排序】原理：

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素做同样的工作, 从开始第一对到结尾的最后一对, 在这一点，最后的元素应该会是最大的数。

var arr = [12, 3, 569, 78, 0, -56, 1223, 11, 16, 13, 1, 12];
function bubbleSort(arr) {
    if (Array.isArray(arr)) { //是数组
        for (var i = 0; i < arr.length - 1; i++) { //控制轮数  -1：12个数字只需要比较11轮
            for (var j = 0; j < arr.length - i - 1; j++) { //第i轮，表示已经排序好i个数字。  -1:12个数字两两比较11次。
                if (arr[j] > arr[j + 1]) { //比较相邻的元素。 如果第一个比第二个大， 就交换他们两个
                    var temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return arr;
    } else { //不是数组
        throw new Error('请输入数组'); //新建错误对象，包含错误信息，抛出错误 throw
    }
}
console.log(bubbleSort(arr))

【选择排序】原理：

第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置

然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾

以此类推，直到全部待排序的数据元素的个数为零

var arr = [12, 3, 569, 78, 0, -56, 1223, 11, 16, 13, 1, 12];
function selectSort(arr) {
    if (Array.isArray(arr)) { //是数组
        for (var i = 0; i < arr.length; i++) {
            var minindex = i;  //依次假设的最小值的索引下标为i
            var minvalue = arr[minindex];  ////假设的最小值
            for (var j = i + 1; j < arr.length; j++) {
                if (arr[j] < minvalue) { //如果当前的数组项的值比最小值还要小，当前的值就是这次最小值
                    minvalue = arr[j];  //当前的值就是最小值
                    minindex = j;  //此时的j就是最小值的索引下标
                }
            }
            //内层的for循环走完一轮，才能得到真正的最小值。才可以进行交换
            if(minindex !== i){  //代表当前假设的最小值不成立的。找到真正的最小值的索引下标
                var temp = arr[minindex];
                arr[minindex] = arr[i];
                arr[i] = temp;
            }
        }
        return arr;
    } else { //不是数组
        throw new Error('请输入数组'); //新建错误对象，包含错误信息，抛出错误 throw
    }
}
console.log(selectSort(arr))

【快速排序】原理：

待排序的数组中任意截取(splice:改变原数组)一位,截取相对中间一些的位置 - 中间值

准备两个数组left/right，用余下的数字分别和中间值进行比较

如果比截取的中间值大放到right数组(push)，如果比中间值小放到左边的数组(push)

分别对left和right数组进行递归操作，直到数组的每一项长度为1或者0(基点)

最终利用concat方法将所有的数组连接起来

var arr = [12, 3, 3, 3, 3, 569, 78, 0, -56, 1223, 1223, 1223, 11, 16, 13, 1, 12];

function quickSort(arr) {
    if (Array.isArray(arr)) { //数组
        if (arr.length <= 1) { //长度<=1 输出数组项的值，设为基点
            return arr;
        } else { //长度>1 进行递归比较
            var midindex = parseInt(arr.length / 2) //获取中间值的索引
            var midvalue = arr.splice(midindex, 1)[0]; //改变原数组，截取1位。返回值还是数组。
            var left = [];
            var right = [];
            for (var i = 0; i < arr.length; i++) {
                if (arr[i] < midvalue) {
                    left.push(arr[i]);
                } else { //排序
                    right.push(arr[i]);
                }
                // else if (arr[i] > midvalue) {//排序+去重
                //     right.push(arr[i]);
                // }
            }
            return quickSort(left).concat(midvalue, quickSort(right)); //最终的拼接
        }
    } else {
        throw new Error('请输入数组');
    }
}
console.log(quickSort(arr));

算法 - 冒泡排序、选择排序、快速排序

猜你喜欢