【广州前端】JavaScript实现十种经典排序算法（2） - 黑马程序员技术交流社区

黑马程序员技术交流社区

标题:

作者:

时间:

标题:

六。快速排序算法

快速排序是由东尼·霍尔所发展的一种排序算法。它是处理大数据最快的排序算法之一。快速排序是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。快速排序算法的步骤描述如下：

从数列中挑出一个元素，称为 “基准”（pivot）;

重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

JavaScript实现快速排序算法的代码如下：

[JavaScript] 纯文本查看 复制代码

function quickSort(arr, left, right) {

    var len = arr.length,

        partitionIndex,

        left = typeof left != 'number' ? 0 : left,

        right = typeof right != 'number' ? len - 1 : right;

 

    if (left < right) {

        partitionIndex = partition(arr, left, right);

        quickSort(arr, left, partitionIndex-1);

        quickSort(arr, partitionIndex+1, right);

    }

    return arr;

}

 

function partition(arr, left ,right) {     // 分区操作

    var pivot = left,                      // 设定基准值（pivot）

        index = pivot + 1;

    for (var i = index; i <= right; i++) {

        if (arr < arr[pivot]) {

            swap(arr, i, index);

            index++;

        }        

    }

    swap(arr, pivot, index - 1);

    return index-1;

}

 

function swap(arr, i, j) {

    var temp = arr;

    arr = arr[j];

    arr[j] = temp;

}

functiion paritition2(arr, low, high) {

  let pivot = arr[low];

  while (low < high) {

    while (low < high && arr[high] > pivot) {

      --high;

    }

    arr[low] = arr[high];

    while (low < high && arr[low] <= pivot) {

      ++low;

    }

    arr[high] = arr[low];

  }

  arr[low] = pivot;

  return low;

}

 

function quickSort2(arr, low, high) {

  if (low < high) {

    let pivot = paritition2(arr, low, high);

    quickSort2(arr, low, pivot - 1);

    quickSort2(arr, pivot + 1, high);

  }

  return arr;

}

七。堆排序算法
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆排序算法的步骤描述如下：
创建一个堆 H[0……n-1]；
把堆首（最大值）和堆尾互换；
把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；
重复步骤 2，直到堆的尺寸为 1。

JavaScript实现堆排序算法的代码如下：
[JavaScript] 纯文本查看 复制代码
var len; // 因为声明的多个函数都需要数据长度，所以把len设置成为全局变量

function buildMaxHeap(arr) { // 建立大顶堆
len = arr.length;
for (var i = Math.floor(len/2); i >= 0; i--) {
      heapify(arr, i);
}
}

function heapify(arr, i) {    // 堆调整
var left = 2 * i + 1,
      right = 2 * i + 2,
      largest = i;

if (left < len && arr[left] > arr[largest]) {
      largest = left;
}

if (right < len && arr[right] > arr[largest]) {
      largest = right;
}

if (largest != i) {
      swap(arr, i, largest);
      heapify(arr, largest);
}
}

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

function heapSort(arr) {
buildMaxHeap(arr);

for (var i = arr.length-1; i > 0; i--) {
      swap(arr, 0, i);
      len--;
      heapify(arr, 0);
}
return arr;
}
八。计数排序算法
计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
JavaScript实现计数排序算法的代码如下：
[JavaScript] 纯文本查看 复制代码
function countingSort(arr, maxValue) {
var bucket = new Array(maxValue+1),
      sortedIndex = 0;
      arrLen = arr.length,
      bucketLen = maxValue + 1;

for (var i = 0; i < arrLen; i++) {
      if (!bucket[arr]) {
         bucket[arr] = 0;
      }
      bucket[arr]++;
}

for (var j = 0; j < bucketLen; j++) {
      while(bucket[j] > 0) {
         arr[sortedIndex++] = j;
         bucket[j]--;
      }
}

return arr;
}
九。桶排序算法
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。
JavaScript实现桶排序算法的代码如下：
[JavaScript] 纯文本查看 复制代码
function bucketSort(arr, bucketSize) {
if (arr.length === 0) {
   return arr;
}

var i;
var minValue = arr[0];
var maxValue = arr[0];
for (i = 1; i < arr.length; i++) {
   if (arr < minValue) {
      minValue = arr;             // 输入数据的最小值
   } else if (arr > maxValue) {
      maxValue = arr;             // 输入数据的最大值
   }
}

//桶的初始化
var DEFAULT_BUCKET_SIZE = 5;          // 设置桶的默认数量为5
bucketSize = bucketSize || DEFAULT_BUCKET_SIZE;
var bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;
var buckets = new Array(bucketCount);
for (i = 0; i < buckets.length; i++) {
      buckets = [];
}

//利用映射函数将数据分配到各个桶中
for (i = 0; i < arr.length; i++) {
      buckets[Math.floor((arr - minValue) / bucketSize)].push(arr);
}

arr.length = 0;
for (i = 0; i < buckets.length; i++) {
      insertionSort(buckets);                   // 对每个桶进行排序，这里使用了插入排序
      for (var j = 0; j < buckets.length; j++) {
         arr.push(buckets[j]);
      }
}

return arr;
}
十。基数排序算法
基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。
JavaScript实现基数排序算法的代码如下：
[JavaScript] 纯文本查看 复制代码
var counter = [];
function radixSort(arr, maxDigit) {
var mod = 10;
var dev = 1;
for (var i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
      for(var j = 0; j < arr.length; j++) {
         var bucket = parseInt((arr[j] % mod) / dev);
         if(counter[bucket]==null) {
            counter[bucket] = [];
         }
         counter[bucket].push(arr[j]);
      }
      var pos = 0;
      for(var j = 0; j < counter.length; j++) {
         var value = null;
         if(counter[j]!=null) {
            while ((value = counter[j].shift()) != null) {
                  arr[pos++] = value;
            }
      }
      }
}
return arr;
}
点击查看更多精彩前端资源
点击有惊喜

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2