2.排序算法实现(JavaScript版)-冒泡-选择-快速排序

Posted lanshanxiao

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了2.排序算法实现(JavaScript版)-冒泡-选择-快速排序相关的知识,希望对你有一定的参考价值。

以下代码都是javascript实现

1.冒泡排序

技术图片
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        //排序的本质是比较和交换

        //-----------冒泡排序-------begin---------//
        //写一个冒泡排序函数
        function sort(arr){
            for(var i = 0; i < arr.length; i++){
                for(var j = 0; j < arr.length - 1 - i; j++){
                    if(compare(arr[j], arr[j + 1])){
                        exchange(arr, j, j + 1);
                    }
                }
            }
        }

        //写一个比较函数
        function compare(a, b){//升序
            return (a > b) ? true : false;
        }

        //写一个交换函数
        function exchange(arr, a, b){
            var temp = arr[a];
            arr[a] = arr[b];
            arr[b] = temp;
        }
        //-----------冒泡排序-------end---------//
        //冒泡排序测试
        var arr = [5, 4, 3, 2, 1];
        sort(arr);
        console.log(arr);

    </script>
</body>
</html>
冒泡排序.html

 

2.选择排序

技术图片
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        //排序的本质是比较和交换

        
        //-----------选择排序-------begin-------//
        //写一个选择排序函数
        function sort(arr){
            //选择排序,内层循环,每次挑出一个最大的值,放到最后面
            for(var i = 0; i < arr.length; i++){
                var maxIndex = 0;//每次都假设最大值在arr[0]上
                for(var j = 0; j < arr.length - i; j++){
                    if(compare(arr[maxIndex], arr[j])){
                        maxIndex = j;//替换最大值的索引
                    }
                }
                exchange(arr, maxIndex, arr.length - 1 - i);//每圈循环后,把最大值放在最后
            }
        }

        //写一个比较函数
        function compare(a, b){//升序
            return (a < b) ? true : false;
        }

        //写一个交换函数
        function exchange(arr, a, b){
            var temp = arr[a];
            arr[a] = arr[b];
            arr[b] = temp;
        }
        //-----------选择排序-------end-------//
        //选择排序测试
        var arr1 = [5, 4, 3, 2, 1];
        sort(arr1);
        console.log(arr1);


    </script>
</body>
</html>
选择排序.html

 

3.简单的快速排序

技术图片
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        //排序的本质是比较和交换

        //-----容易理解的快速排序-----begin---//
        function quickSort(arr){
            if(arr == null || arr.length == 0) return [];
            //选出排头兵
            var header = arr[0];
            var left = [];
            var right = [];
            for(var i = 1; i < arr.length; i++){
                if(arr[i] > header){//比排头兵大的放右边
                    right.push(arr[i]);
                }else{//比排头兵小的放左边
                    left.push(arr[i]);
                }
            }
            
            
            //左边和右边再次快速排序
            left = quickSort(left);
            right = quickSort(right);
            left.push(header);//把排头兵加到左边最后
            return left.concat(right);//返回左右分开后的数组
        }
        //-----容易理解的快速排序-----begin---//
        //容易理解的快速排序测试
        var arr2 = [9, 3, 5, 6, 2, 1, 7, 8, 0, 4];
        console.log(quickSort(arr2));

    </script>
</body>
</html>
简单的快速排序.html

 

4.标准的快速排序

技术图片
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        //排序的本质是比较和交换


        //----标准的快速排序--------begin-----//
        function standardQuickSort(arr, begin, end){
            if(begin >= end) return;//若开始位置大于等于结束位置,直接返回
            var left = begin;//左 指向 头
            var right = end;//右 指向 尾
            do{
                do left++; while(left < right && arr[left] < arr[begin])//left右移一位,比较left和right的大小,以及比较arr[left]和arr[begin]的大小
                do right--; while(right > left && arr[right] > arr[begin])//right左移一位,比较left和right的大小,以及比较arr[right]和arr[begin]的大小
                if(left < right) exchange(arr, left, right);//交换左右的值,说明arr[left]>arr[begin]并且arr[right]<arr[begin];
            }while(left < right)//当L < R时,一直执行循环
            var swapPoint = left == right ? right - 1 : right;//判断arr[begin]要放在数组的位置
            exchange(arr, begin, swapPoint);//交换位置
            standardQuickSort(arr, begin, swapPoint);//比arr[begin]小的重新排序
            standardQuickSort(arr, swapPoint + 1, end);//比arr[begin]大的重新排序
        }

        function exchange(arr, a, b){
            var temp = arr[a];
            arr[a] = arr[b];
            arr[b] = temp;
        }
        //----标准的快速排序--------end-------//
        //标准的快速排序测试
        var arr3 = [9, 8, 7, 6, 5, 4, 3, 2, 1];
        standardQuickSort(arr3, 0, arr3.length);
        console.log(arr3);

    </script>
</body>
</html>
标准的快速排序.html

 

以上是关于2.排序算法实现(JavaScript版)-冒泡-选择-快速排序的主要内容,如果未能解决你的问题,请参考以下文章

JavaScript算法(冒泡排序选择排序与插入排序)

冒泡排序算法JAVA实现版

图解算法系列之冒泡排序(Low版)

JavaScript实现常见排序算法:冒泡,插入,选择,归并,快速,堆排序

10种经典排序算法的JavaScript实现方法

十大经典排序算法(Javascript版)