排序

直接插入排序

    var readline = require('readline');
    const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout
    });
    rl.on('line', function(line) {

    //直接插入排序

    /**算法思想：
    时间复杂度：
    最坏：序列全部逆序，此时为 O(n^2);
    最好：序列全部正序，此时为 O(n);
    空间复杂度：O(1);*/

    //直接插入排序核心算法
    var array = line.split(' ');
    for(var i=0; i<array.length; i++){
        array[i]= parseInt(array[i]);
    }

    for(var j=1;j<array.length;j++){
        var temp = array[j];
        var res = j-1;
        while (res>=0 && temp<array[res]){
            array[res+1]=array[res];
            --res;
        }
        array[res+1]=temp;
    }
    console.log(array);
});

冒泡排序

    var readline = require('readline');
           const rl = readline.createInterface({
               input: process.stdin,
               output: process.stdout
           });
            rl.on('line', function(line){
                /**
                 * 冒泡排序：
                 * 思想：外循环：n->2,内循环->1-n,前一个数大于后一个数->交换位置
                 * 注意事项：外循环跳出的条件是内循环没有发生元素交换
                 * 最好情况：0(n),最差：O(n^2)
                 */

                 var array = line.split(' ').map(function (p1, p2, p3) {
                     return parseInt(p1);
                 });
                for(var i =array.length; i>=1; i--){
                    var flag = false;
                    for(var j=1;j<=i; j++){
                        if(array[j]<array[j-1]){
                            var temp = array[j];
                            array[j] = array[j-1];
                            array[j-1] = temp;
                            flag=true;
                        }
                    }
                    if(!flag){break}
                }
                console.log(array);
            });

快速排序

var readline = require('readline');
           const rl = readline.createInterface({
               input: process.stdin,
               output: process.stdout
           });
            rl.on('line', function(line){
                /**
                 * 快速排序：
                 * 思想：选择第一个数字做为枢轴，并保存它的值temp,设置两个指针，先从后指针向前扫描，如果遇到比这个数小的，
                 * 覆盖掉前指针所对应的值，再从前指针向后扫描，遇到比这个数大的值覆盖掉后指针对应的值，循环停止条件是:
                 * low=high,最后low/high的值就是temp需要插入的位置，一次排序之后左边的数列所有值小于枢轴，右侧大于枢轴，然后
                 * 再递归对左、右数列进行同样的排序。
                 * 最差情况：0(n^2),平均时间复杂度：O(n*log2n)
                 */
                var array = line.split(' ').map(function (p1, p2, p3) {
                     return parseInt(p1);
                 });
                function test(arr,l,r) {
                 var i=l;
                 var j=r;
                 if(l<r){
                     var temp = arr[l];
                 }
                 while (i!==j){
                    while (i<j && arr[j]>temp) --j;
                     i<j ? arr[i] = arr[j] : arr;
                     while (i<j && arr[i]<temp) ++i;
                     i<j ? arr[j]  = arr[i] : arr;
                 }
                 arr[i]=temp;
                 return i;
             };
                function QuickSort(arr,l,r) {
                    if (l < r) {
                        var i = test(arr, l, r);
                        QuickSort(arr, l, i - 1);
                        QuickSort(arr, i + 1, r);
                        return arr
                    }
                }
                //QuickSort(array,0,array.length-1);
                /*第二种快速排序算法简写
                * 取数组中间元素为枢轴元素
                * 对于每次递归：
                * 保存这个元素，并从该数组中删除这个元素
                * 依次遍历这个数组->比这个数小放在left数组里->比它大放在right数组里
                * 递归left和right数组
                * */
                var QuickSort2 = function(arr){
                    //枢轴取数组中间的元素
                    //注意递归跳出条件
                    if (arr.length <= 1) { return arr; }
                    var targetL = Math.floor(arr.length/2 );
                    var target = arr.splice(targetL,1)[0];
                    var left=[];
                    var right=[];
                    for(var i=0;i<arr.length;i++){
                        arr[i]<target ? left.push(arr[i]) : right.push(arr[i])
                    }
                    return QuickSort2(left).concat([target],QuickSort2(right));
                };

                console.log(QuickSort2(array));
            });

简单选择排序

    var readline = require('readline');
           const rl = readline.createInterface({
               input: process.stdin,
               output: process.stdout
           });
            rl.on('line', function(line){
               var array = line.split(' ').map(function (p1, p2, p3) {
                   return parseInt(p1);
               });
               /*简单选择排序
               * 依次遍历这个数组，对于每个外循环的target,内循环每次从剩下的元素中选择一个最小的元素，分别与target交换
               * */
                for(var i=0; i<array.length; i++){
                    var min =i;
                    for(var j=i+1;j<array.length;j++){
                        if(array[j]<array[min]){
                            min=j;
                        }
                    }
                    var temp = array[i];
                    array[i] = array[min]
                    array[min] = temp;
                }
                console.log(array);

            });