排序算法总结(js代码实现,思想通用)


<html>
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>sorttitle>
    <link rel="stylesheet" href="">
head>
<body>
    <script>

        //测试用例
        var a=[1,3,8,2,6,9,7,13,25,45,18];
        console.log(a);


        //1.冒泡排序
        function bubbleSort(arr){
            var len=arr.length;
            for(var i=0;i1;i++){
                for(var j=0;j1-i;j++){
                    if(arr[j]>arr[j+1]){            //相邻元素比较
                        var temp=arr[j+1];          //两两交换
                        arr[j+1]=arr[j];
                        arr[j]=temp;
                    }
                }
            }
            return arr;
        }


        //2.选择排序
        function selectionSort(arr){
            var len=arr.length;
            var minIndex,temp;
            for(var i=0;i1;i++){
                minIndex=i;
                for(var j=i;j1;j++){
                    if(arr[j]//寻找最小的数
                        minIndex=j;                 //保存最小数的索引
                    }
                }
                temp=arr[i];                        //将找出的最小数与比较的数进行两两交换
                arr[i]=arr[minIndex];
                arr[minIndex]=temp;
            }
            return arr;
        }


        //3.插入排序
        function insertionSort(arr){
            var len=arr.length;
            var preIndex,current;
            for(var i=1;i1;                       //记录前一个位置
                current=arr[i];                     //记录当前位置的值
                while(preIndex>0 && arr[preIndex]>current){             //当下标大于零时且要比较的值大于当前的值,将与当前值比较的值往后移
                    arr[preIndex+1]=arr[preIndex];
                    preIndex--;
                }
                arr[preIndex+1]=current;                                //循环结束时,将当前值插入对应的位置即可
            }
            return arr;
        }


        //4.希尔排序
        function shellSort(arr){
            var len=arr.length;
            var gap=Math.floor(len/2);                      //步长或增量
            while(gap>=1){
                for(var i=gap;ivar temp=arr[i];                        //记录当前要比较的值
                    for(var j=i-gap; j>=0 && temp//循环递减步长长度与temp比较
                        arr[j+gap]=arr[j];
                    }
                    arr[j+gap]=temp;
                }
                gap=Math.floor(gap/2);              //改变步长
            }
            return arr;                             //返回结果
        }       


        //5.归并排序
        function mergeSort(arr){                //采用自上而下的递归方式
            var len=arr.length;
            if(len<2){                          //如果元素个数少于2个,则直接返回数组
                return arr;
            }
            var middle=Math.floor(len/2),       //一分为二,记录中间元素下标
                left=arr.slice(0,middle),       //以中间位置分的左边的数组
                right=arr.slice(middle);        //以中间位置分的右边的数组
            return merge(mergeSort(left),mergeSort(right));         //递归调用
        }

        function merge(left,right){             //传入两个参数,一个是左数组,一个是右数组

            var result=[];

            while(left.length && right.length){     //左边数组和右边数组必须都存在元素时
                if(left[0]<=right[0]){
                    result.push(left.shift());      //如果左边数组第一个元素小,则取出左边数组中第一个元素,并放入结果数组中
                }else{
                    result.push(right.shift());     //如果右边数组第一个元素小,则取出右边数组中第一个元素,并放入结果数组中
                }
            }

            while(left.length){                 //如果左边数组还有元素,则全部并入
                result.push(left.shift());
            }

            while(right.length){
                result.push(right.shift());     //如果右边数组还有元素,则全部并入
            }

            return result;                      //返回结果数组
        }


        //6.快速排序
        function quickSort(arr,low,high){   
            if(lowvar pos=qkPass(arr,low,high);               //将参数传入函数,调用排序函数,并接受返回的基准值的索引
                quickSort(arr,low,pos-1);                   //索引左边不包含索引位置,将左边划分的数组进行递归调用
                quickSort(arr,pos+1,high);                  //索引右边不包含索引位置,将右边划分的数组进行递归调用
            }
            return arr;                                     //返回结果数组
        }

        function qkPass(arr,low,high){
            var base=arr[low];                              //默认第一个元素为基准值
            while(lowwhile(lowbase){          //从右边最高位置的元素与基准值进行比较,如果大于基准值,则自减一
                    --high;
                }
                arr[low]=arr[high];                         //若找到比基准值小的元素,则将其赋值给arr[low]

                while(low//从左边最低位置的元素与基准值进行比较,如果小于或等于基准值,则自加一
                    ++low;
                }
                arr[high]=arr[low];                         //若找到比基准值大的元素,则将其赋值给arr[high]
            }
            arr[low]=base;                                  //最后将基准值赋给arr[low]

            return low;                                     //返回基准值所在位置的索引
        }





        //测试
        console.log(bubbleSort(a));
        console.log(selectionSort(a));
        console.log(insertionSort(a));
        console.log(shellSort(a));
        console.log(mergeSort(a));
        console.log(quickSort(a,0,10));


    script>
body>
html>

想了解更多排序算法及其详情内容请点击此处!!!

你可能感兴趣的:(js,算法,排序算法)