常见排序算法JavaScript实现

//1.插入排序 

        function insertionSort(array) {

            //判断传入参数的类型，插入排序是基于数组实现的

            if (Object.prototype.toString.call(array).slice(8, -1) === 'Array') {

                for (var i = 1; i < array.length; i++) {

                    //第一项array[0]默认已经被排序，从第二项开始取出元素

                    var key = array[i];

                    var j = i - 1;

                    //从后往前扫描已排序的元素，若待排序的元素小于已排序的元素，将已排序的元素后移一位，

                    //循环，直到找到小于或等于新元素的位置

                    while (j >= 0 && array[j] > key) {

                        array[j + 1] = array[j];

                        j--;

                    }

                    //将新元素插入到该位置后

                    array[j + 1] = key;

                }

                return array;

            } else {

                //若传入参数不是数组，提示用户

                return 'array is not an Array!';

            }

        }

        // var arr = insertionSort([1,3,4,9,2,5,7,13]);

        // console.log(arr);

        //算法分析：

        //最佳时间复杂度：T(n)=O(n)数组升序排列

        //最坏时间复杂度：T(n)=O(n^2)数组降序排列

        //平均时间复杂度：T(n)=O(n^2)

 

        //2.二分插入排序

        function binaryInsertionSort(array) {

            //判断传入参数的类型，插入排序是基于数组实现的

            if (Object.prototype.toString.call(array).slice(8, -1) === 'Array') {

                for (var i = 1; i < array.length; i++) {

                    //第一项array[0]默认已经被排序，从第二项开始取出元素

                    var key = array[i];

                    //二分查找第一个比它大的数的位置

                    var left = 0;

                    var right = i - 1;

                    while (left <= right) {

                        var mid = parseInt((left + right) / 2);

                        if (key < array[mid]) {

                            right = mid - 1;

                        } else {

                            left = mid + 1;

                        }

                    }

                    //将排好序的数组从第一个比新元素大的元素开始都后移一位

                    for (var j = i - 1; j >= left; j--) {

                        array[j + 1] = array[j];

                    }

                    //将新元素插入到该位置

                    array[left] = key;

                }

                return array;

            } else {

                //若传入参数不是数组，提示用户

                return 'array is not an Array!';

            }

        }

        // var arr = binaryInsertionSort([3, 1, 4, 9, 2, 5, 7, 13]);

        // console.log(arr);

        //算法分析：

        //最佳时间复杂度：T(n)=O(nlog2n)

        //最坏时间复杂度：T(n)=O(n^2)

        //平均时间复杂度：T(n)=O(n^2)

 

        //3.选择排序

        function selectionSort(array) {

            //判断传入参数的类型

            if (Object.prototype.toString.call(array).slice(8, -1) === 'Array') {

                for (var i = 0; i < array.length - 1; i++) {

                    //循环寻找未排序区的最小值放入排序区

                    var min = array[i];

                    for (var j = i + 1; j < array.length; j++) {

                        if (array[j] < min) {

                            //交换

                            array[j] = min + array[j] - (min = array[j]);

                        }

                    }

                    array[i] = min;

                }

                return array;

            } else {

                //若传入参数不是数组，提示用户

                return 'array is not an Array!';

            }

        }

        // var arr = selectionSort([3, 1, 4, 9, 2, 5, 7, 13]);

        // console.log(arr);

        //算法分析：

        //最佳时间复杂度：T(n)=O(n^2)

        //最坏时间复杂度：T(n)=O(n^2)

        //平均时间复杂度：T(n)=O(n^2)

 

        //4.冒泡排序

        function bubbleSort(array) {

            //判断传入参数的类型

            if (Object.prototype.toString.call(array).slice(8, -1) === 'Array') {

                for (var i = 0; i < array.length - 1; i++) {

                    for (var j = 0; j < array.length - i - 1; j++) {

                        if (array[j] > array[j + 1]) {

                            //交换

                            array[j] = array[j + 1] + array[j] - (array[j + 1] = array[j]);

                        }

                    }

                }

                return array;

            } else {

                //若传入参数不是数组，提示用户

                return 'array is not an Array!';

            }

        }

        // var arr = bubbleSort([3, 1, 4, 9, 2, 5, 7, 13]);

        // console.log(arr);

        //算法分析：

        //最佳时间复杂度：T(n)=O(n)

        //最坏时间复杂度：T(n)=O(n^2)

        //平均时间复杂度：T(n)=O(n^2)

 

        //5.快速排序

        function getIndex(array, left, right) {

            if (left >= right) return array;

            let key = array[right];

            while (left < right) {

                while (array[left] < key) {

                    left++;

                }

                while (array[right] > key) {

                    right--;

                }

                if (left < right) {

                    array[left] = array[left] + array[right] - (array[right] = array[left]);

                }

            }

            array[left] = key;

            return left;

        }

        function quickSort(array, left, right) {

            //判断传入参数的类型

            if (Object.prototype.toString.call(array).slice(8, -1) === 'Array') {

                let index = getIndex(array, left, right);

                if (left <= index - 1) {

                    quickSort(array, left, index - 1);

                }

                if (right >= index + 1) {

                    quickSort(array, index + 1, right);

                }

                return array;

            } else if (array.length === 1) {

                return array;

            } else if (array.length < 1) {

                return 'Array is null';

            } else {

                //若传入参数不是数组，提示用户

                return 'array is not an Array!';

            }

        }

 

        // var arr = [3, 1, 4, 9, 2, 5, 7, 13];

        // console.log(quickSort(arr, 0, arr.length - 1));

        //算法分析：

        //最佳时间复杂度：T(n)=O(nlog2n)

        //最坏时间复杂度：T(n)=O(n^2)

        //平均时间复杂度：T(n)=O(nlog2n)

 

        //6.归并排序

        function merge(array, first, mid, last) {

            var temp = [];

            let i = first;

            let j = mid + 1;

            let k = 0;

            while (i <= mid && j <= last) {

                if (array[i] < array[j]) {

                    temp[k++] = array[i++];

                } else {

                    temp[k++] = array[j++];

                }

            }

            while (i <= mid) {

                temp[k++] = array[i++];

            }

            while (j <= last) {

                temp[k++] = array[j++];

            }

            for (let n = 0; n < k; n++) {

                array[first + n] = temp[n];

            }

            return array;

        }

        function mergeSort(array, first, last) {

            //判断传入参数的类型

            if (Object.prototype.toString.call(array).slice(8, -1) === 'Array') {

                if (first < last) {

                    var mid = parseInt((first + last) / 2);

                    if (first < mid) {

                        mergeSort(array, first, mid);

                    }

                    if (last > mid + 1) {

                        mergeSort(array, mid + 1, last);

                    }

                    array = merge(array, first, mid, last);

                }

                return array;

            } else {

                //若传入参数不是数组，提示用户

                return 'array is not an Array Or params Wrong';

            }

        }

        // var arr = [3, 1, 4, 9, 2, 5, 7, 13];

        // console.log(mergeSort(arr, 0, arr.length - 1));

        //算法分析：

        //最佳时间复杂度：T(n)=O(n)

        //最坏时间复杂度：T(n)=O(nlog2n)

        //平均时间复杂度：T(n)=O(nlog2n)

 

        //7.堆排序

        function swap(array, a, b) {

            array[a] = array[a] + array[b] - (array[b] = array[a]);

        }

        function maxHeapify(array, parentNode, length) {

            let max = parentNode;

            let left = parentNode * 2 + 1;

            let right = parentNode * 2 + 2;

            if (left < length && array[left] > array[max]) {

                max = left;

            }

            if (right < length && array[right] > array[max]) {

                max = right;

            }

            if (max !== parentNode) {

                swap(array, parentNode, max);

                maxHeapify(array, max, length);

            }

        }

        function buildMaxHeap(array) {

            //自底向上，从最后一个拥有叶子节点的结点开始，堆的大小等于数组长度

            let parentNode = Math.floor(array.length / 2) - 1;

            for (let i = parentNode; i >= 0; i--) {

                maxHeapify(array, i, array.length);

            }

        }

        function heapSort(array) {

            //判断传入参数的类型

            if (Object.prototype.toString.call(array).slice(8, -1) === 'Array') {

                //升序排列，建大根堆

                buildMaxHeap(array);

                console.log(array);

                //堆排序

                for (let i = array.length - 1; i > 0; i--) {

                    swap(array, 0, i);

                    maxHeapify(array, 0, i);

                }

                return array;

            } else {

                //若传入参数不是数组，提示用户

                return 'array is not an Array!';

            }

        }

        var arr = [3, 1, 4, 9, 2, 5, 7, 13];

        console.log(heapSort(arr));

        //算法分析：

        //最佳时间复杂度：T(n)=O(nlog2n)

        //最坏时间复杂度：T(n)=O(nlog2n)

        //平均时间复杂度：T(n)=O(nlog2n)