堆排序

堆排序的基本思想是：将待排序序列构形成一个大顶堆，此时，全部序列的最大值就是堆顶的根节点。将其与末端元素举行交流，此时末端就为最大值。然后将盈余n-1个元素从新构形成一个堆，如许会获得n个元素的次小值。云云重复实行，便能获得一个有序序列了

arr = [20,50,20,40,6,878,70,10,80,30,60,9,44];
    console.log("排序之前：" + arr);

    heapSort(arr);
    console.log("排序以后：" + arr);

    function heapSort(arr) {
      var end = arr.length -1;
      for (var i = parseInt(arr.length/2) -1; i >= 0; i--) {
        heapAdjust(arr,i,end);
      }
      while(end >= 0) {
        swap(arr,0,end--);    //将堆顶元素与尾节点交流后，长度减1，尾元素最大
        heapAdjust(arr,0,end);    //再次对堆举行调解
      }
    }

    function heapAdjust(arr,i,end) {
      var left = 2*i+1, right, flag;
      while(left <= end){  //推断当前父节点有没有左节点（即有没有孩子节点，left为左节点）
        right = left +1;
        flag = left;
        if (right <= end && arr[left] < arr[right]) {
          flag = right;
        }
        if(arr[i] < arr[flag])    //将父节点与孩子节点交流（假如上面if为真，则arr[flag]为右节点，假如为假arr[flag]则为左节点）
            swap(arr,i,flag);
        else         //申明比孩子节点都大，直接跳出轮回语句
            break;
        i = flag;
        left = 2*i+1;
      }
    }

    function swap(arr, i, j){
      var temp = arr[i];
      arr[i] = arr[j];
      arr[j] = temp;
    }

兼并排序

兼并排序，其的基本思路就是将数组分红二组A，B，假如这二组组内的数据都是有序的，那末就能够很轻易的将这二组数据举行排序。怎样让这二组组内数据有序了？

能够将A，B组各自再分红二组。顺次类推，当分出来的小组只要一个数据时，能够以为这个小组组内已达到了有序，然后再兼并相邻的二个小组就能够了。如许经由历程先递归的剖析数列，再兼并数列就完成了兼并排序。

// 兼并排序
        myarr=[2,43,4,7,4,766,7,3,324,54,5455,89];
        console.log("兼并排序前：" + myarr);
        mergeSort(myarr, myarr.length);
        console.log("兼并排序后：" + myarr);

        function mergeSort(arr, len) {
            var tmpArr = new Array(len);
            mergeSortDevide(arr,0,len-1,tmpArr);
            tmpArr = [];
            return true;
        }

        function mergeSortDevide(arr, first, last, tempArr) {
            if (first < last) {
                var mid = parseInt((first + last)/2);
                mergeSortDevide(arr,first,mid,tempArr);
                mergeSortDevide(arr,mid+1,last,tempArr);
                mergeArray(arr,first,mid,last,tempArr)
            }
        }

        function mergeArray(arr,first,mid,last,tempArr) {
            var i = first, j = mid + 1, m = mid, n = last;
            var k = 0;
            while(i <= m && j <= n){
                if (arr[i] <= arr[j]) {
                    tempArr[k++] = arr[i++];
                } else {
                    tempArr[k++] = arr[j++];
                }
            }

            while(i <= m) {
                tempArr[k++] = arr[i++];
            }
            while(j <= n) {
                tempArr[k++] = arr[j++];
            }

            for(t = 0; t < k; t++){
                arr[first + t] = tempArr[t];
            }

        }

疾速排序

关于一字给定的纪录，经由历程一趟排序后，将原序列分为两部分，个中前一部分的一切纪录均比后一部分的一切纪录小，然后再一次对前后两部分的纪录举行疾速排序，递归该历程，指点序列中一切纪录均有序为止。

// 疾速排序
        function quickSort(arr, low, high) {
            var i,j,index;
            if (low>high)
                return;
            i = low;
            j = high;
            index = arr[i];
            while(i < j) {
                while(i<j && arr[j] > index)
                    j--;
                if(i<j)
                    arr[i++] = arr[j];
                while(i<j && arr[i] < index)
                    i++;
                if (i < j)
                    arr[j--] = arr[i];
            }
            arr[i] = index;
            quickSort(arr, low, i-1);
            quickSort(arr, i+1, high);
        }

        arr3=[3,2,8,12,0,43,21,16,68,78,4];
        quickSort(arr3,0,arr3.length-1);
        console.log(arr3);