JS数组10种排序一

1、冒泡排序

    // 一；冒泡排序：相邻两元素之间两两比较，比较出大值进行赋值互换，
    //    再依次与相邻的元素比较，层层递进 #互换元素位置，相互赋值。
    function popSort(arr) {
      if (arr == null) return arr;
      for (var i = 0; i < arr.length; i++) {
        for (var j = 0; j < arr.length; j++) {
          if (arr[j] < arr[j - 1]) {
            var temp = arr[j - 1];
            arr[j - 1] = arr[j];
            arr[j] = temp;
          }
        }
      }
    }
    popSort(arr);

2、选择排序

//二，选择排序，先定义一个元素的最大值与最小值，拿 每个元素与最值比较，
    //  取小值放到元素最左端，层 层比较，#互换元素下标位置，再赋值，
    //  所以比冒泡排序的效率高，
    function selectSort(arr) {
      if (arr == null) return arr;
      var minIndex, temp;
      for (var i = 0; i < arr.length; i++) {
        minIndex = i;
        for (var j = i + 1; j < arr.length; j++) {
          if (arr[j] < arr[minIndex]) {
            minIndex = j;
          }
        }
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
      }
    }
     selectSort(arr);

快排

    //三；快排
    // 大致分三步：
    // 1、找基准（一般是以中间项为基准）
    // 2、遍历数组，小于基准的放在left，大于基准的放在right
    // 3、递归
    function quickSort(arr) {
      var left = [], right = [];
      if (arr == null) {
        return arr;
      } else if (arr.length <= 1) {
        return arr;
      }
      var num = arr.splice([Math.floor(arr.length / 2)], 1)[0];

      for (var i = 0; i < arr.length; i++) {
        if (arr[i] <= num) {
          left.push(arr[i]);
        } else {
          right.push(arr[i]);
        }
      }
      return (quickSort(left).concat([num], quickSort(right)));
    }
    alert(quickSort(arr));

插入排序

    //四：插入排序
    //从第二个元素起，当前元素与靠前的元素依次对比，一、如果当前元素小于靠前的元素，
    //靠前的元素后移，直到当前元素大于或等于靠前元素，当前元素插入到靠前索引位置后。
    //二、如果当前元素大于靠前元素，不发生改变。
    //继续从下一个元素开始遍历数组。直当前一个数组角标preIndex+1=arr.length
    function insertSort(arr) {
      var temp;
      for (var i = 1; i < arr.length; i++) {
        for (var j = i; j >= 0; j--) {
          if (arr[j] < arr[j - 1]) {
            temp = arr[j - 1];
            arr[j - 1] = arr[j];
            arr[j] = temp;
          }
        }
      }
    }
    // insertSort(arr);
    // 五：归并排序
    //把数组分成两个数组，左边数组和右边数组
    //分组后的数组继续递归，分组到最小单位（2个数）
    //排序最小单位
    function twoSort(arr) {
      var left, right, temp;
      var len = arr.length;
      if (arr.length == 1) {
        return arr;
      }
      left = arr.splice(0, Math.floor(len / 2));
      right = arr;
      return twoSort(left).concat(twoSort(right));
    }
     alert(twoSort(arr));

堆排序

    //六:堆排序
    //排序的数据结构类似二叉树0-(12) 1-(34) 2-(56) 3-...4-...
    //一、从中间项开始(倒数第二层),比较父节点和子节点的大小，将大值给父节点，最后得到根节点为最大值
    //二、将根节点的值与数组最后一位替换
    //三、排除最大值的节点，继续上述操作
    function heapSort(arr) {
      var num1, num2;
      var len = arr.length;
      while (len != 0) {
        for (var i = Math.floor(len / 2); i >= 0; i--) {
          num1 = 2 * i + 1;
          num2 = num1+1;
          if (num1 <= len) {
            if (arr[i] < arr[num1]) {
              swap(arr, i, num1);
            }
          }
          if (num2 <= len) {
            if (arr[i] < arr[num2]) {
              swap(arr, i, num2);
            }
          }
        }
        swap(arr,0,len);
        len--;
      }
    }
    function swap(arr, a, b) {
      var temp;
      temp = arr[a];
      arr[a] = arr[b];
      arr[b] = temp;
    }
     heapSort(arr);

计数排序

    //七：计数排序
    //把需要处理的数组A的值，作为另外一个数组B的下标
    //统计A中的值出现的次数，保存在B对应下标的值。没有出现，保存为“0”
    //遍历替换A的值赋值数组B值不为零的下标，值为输出次数
    var arr2=[21,21,3,21,21,32,18,3,32];
    function coutSort(arr){
      var max=getMax(arr);
      var arys=new Array(max+1);
      for(var i=0;i<arys.length;i++){
        if(arys[i]==null){
          arys[i]=0;
        }
        for(var j=0;j<arr.length;j++){
          if(i==arr[j]){
            arys[i]++;
          }
        }  
      }
      var cout=0;
      for(var i=0;i<arys.length;i++){
        while(arys[i]>0){
          arr[cout++]=i;
          arys[i]--;
        }
      }
    }
    function getMax(arr){
      var max=arr[0];
      for(var i=0;i<arr.length;i++){
        if(arr[i]>max){
          max=arr[i];
        }
      }
      return max;
    }
    coutSort(arr2);

基数排序

 //八、基数排序（已知最大数的位数）
    //两位数为例。先取个位相同的数组成一个数组（最多10个），将它放进以它个位数为脚标的数组
    //然后将这个嵌套数组的值重新赋值给原来的数组
    //再取十位数的值，进行同样的两步操作，最后得到结果。
    function baseSort(arr,baseNum){
      var arrs;
      var t=10;
      var o=1;
      
      for(var i=0;i<baseNum;i++,t*=10,o*=10){
        var count=0;
        arrs=[];
        for(var j=0;j<10;j++){
          for(var k=0;k<arr.length;k++){
            //num相同时保存在一个数组里
            var num=Math.floor(arr[k]%t/o);
            if(arrs[j]==null){
              arrs[j]=[];
            }
            if(j==num){
              // [23, 9, 19, 27, 88, 38, 99, 28, 8]
              arrs[j].push(arr[k]);
            }
          }
        }
        for(var k=0;k<arrs.length;k++){
          if(arrs[k]==null){
            continue;
          }
          for(var j=0;j<arrs[k].length;j++){
            arr[count++]=arrs[k][j];
          }
        }
      }
    }
    baseSort(arr,2)