排序

直接插入排序

    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);            });