所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际的优秀算法，得经过大量的推理和分析。
算法复杂度分为时间复杂度和空间复杂度。其作用：时间复杂度是指执行算法所需要的计算工作量；而空间复杂度是指执行这个算法所需要的内存空间。
时间频度
一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且每个算法花费的时间与算法中语句的执行次数成正比，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度，记为T(n)。
时间复杂度
在时间频度中，n称为问题的规模，当n不断变化时，时间频度T(n)也会不断变化。但有时我们想知道它变化时呈现什么规律，为此，我们引入时间复杂度概念。一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n) / f(n) 的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n) = O( f(n) )，称O( f(n) )为算法的渐进时间复杂度，简称时间复杂度。
在计算时间复杂度的时候，先找出算法的基本操作，然后根据相应的各语句确定它的执行次数，再找出T(n)的同数量级（它的同数量级有以下：1，log2n, n, nlog2n, n2，n3，2n，n!），找出后，f(n) = 该数量级，若 T(n) / f(n)求极限可得到一常数c，则时间复杂度T(n) = O( f(n) )。
空间复杂度
一个程序的空间复杂度是指运行完一个程序所需内存的大小。利用程序的空间复杂度，可以对程序的运行所需要的内存多少有个预先估计。一个程序执行时除了需要存储空间和存储本身所使用的指令、常数、变量和输入数据外，还需要一些对数据进行操作的工作单元和存储一些为现实计算所需信息的辅助空间。程序执行时所需存储空间包括以下两部分：
a )、固定部分。这部分空间的大小与输入/输出的数据的个数多少、数值无关。主要包括指令空间（即代码空间）、数据空间（常量、简单变量）等所占的空间。这部分属于静态空间。b )、可变空间。这部分空间主要包括动态分配的空间，以及递归栈所需的空间等。这部分的空间大小与算法有关。一个算法所需的存储空间用f(n)表示。S(n) = O( f(n) ) 其中n为问题的规模，S(n) 表示空间复杂度。
分类
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是指在排序期间全部对象太多，不能同时存放在内存中，必须根据排序过程的要求，不断在内，外存间移动的排序。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括：
（一）、冒泡排序算法
冒泡排序是一种简单直观的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
作为最简单的排序算法之一，冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样，每次都在第一页第一位，所以最熟悉。冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。但这种改进对于提升性能来说并没有什么太大作用。
算法步骤
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
效率分析
若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数C和记录移动次数M均达到最小值：Cmin = n – 1, Mmin = 0，所以，冒泡排序最好的时间复杂度为O(n)。
若初始文件是反序的，需要进行n-1趟排序。每趟排序要进行 n-i 次关键字的比较(1 ≤ i ≤ n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：
Cmax = n(n-1)/2 = O(n2)
Mmax = 3n(n-1)/2 = O(n2)
冒泡排序的最坏时间复杂度为O(n2)，综上，因此冒泡排序总的平均时间复杂度为O(n2)。
算法稳定性
冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。
代码实现
<?php
function bubbleSort(array $numbers = array())
{
$count = count($numbers);
if ($count <= 1) return $numbers;
for ($i = 0; $i < $count-1; ++$i) {
for ($j = 0; $j < $count-$i-1; ++$j) {
if($numbers[$j] > $numbers[$j+1]) {
$temp = $numbers[$j];
$numbers[$j] = $numbers[$j+1];
$numbers[$j+1] = $temp;
}
}
}
return $numbers;
}
复制代码（二）、选择排序算法
选择排序是一种简单直接的排序算法。它的工作原理如下，首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移动到其最终位置上，因此对n个元素进行排序总共进行至多n-1次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于好的一种。
算法步骤
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
重复第二步，直到所有元素均排序完毕。
效率分析
在选择排序中，共需要进行n-1次选择和交换，每次选择需要进行 n-i 次比较(1 <= i <= n-1)，而每次交换最多需要3次移动，因此，总的比较次数 C = n (n – 1) / 2。
交换次数为O(n)，最好情况是，已经有序，交换0次；最坏情况是，逆序，交换n-1次。交换次数比冒泡排序较少，由于交换所需CPU时间比冒泡排序所需的CPU时间多，n值较小时，选择排序比冒泡排序快。
原地操作几乎是选择排序的唯一优点，当空间复杂度要求较高时，可以考虑选择排序；实际适用的场合非常罕见。
算法稳定性
选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个 元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。比较拗口，举个例子，序列5 8 5 2 9， 我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法。
代码实现
<?php
function selectSort(array $numbers = array())
{
$count = count($numbers);
if ($count <= 1) return $numbers;
for ($i = 0; $i < $count-1; ++$i) {
$min = $i;
for ($j = $i+1; $j < $count; ++$j) {
if($numbers[$min] > $numbers[$j]) {
$min = $j;
}
}
if($min != $i) {
$temp = $numbers[$min];
$numbers[$min] = $numbers[$i];
$numbers[$i] = $temp;
}
}
return $numbers;
}
复制代码（三）、快速排序算法
快速排序，又称划分交换排序，一种排序算法，最早由东尼·霍尔提出。在平均状况下，排序n个项目要O(n log n)次比较。在最坏状况下则需要O(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他O(n log n)算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。
算法步骤
快速排序使用分治法策略来把一个序列分为两个子序列，步骤：
从数列中挑出一个元素，称为”基准”。
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区操作。
递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代中，它至少会把一个元素摆到它最后的位置去。
效率分析
从一开始快速排序平均需要花费O(n log n)时间的描述并不明显。但是不难观察到的是分区运算，数组的元素都会在每次循环中走访过一次，使用O(n)的时间。在使用结合的版本中，这项运算也是O(n)。
在最好的情况，每次我们运行一次分区，我们会把一个数列分为两个几近相等的片段。这个意思就是每次递归调用处理一半大小的数列。因此，在到达大小为一的数列前，我们只要作log n次嵌套的调用。这个意思就是调用树的深度是O(log n)。但是在同一层次结构的两个程序调用中，不会处理到原来数列的相同部分；因此，程序调用的每一层次结构总共全部仅需要O(n)的时间（每个调用有某些共同的额外耗费，但是因为在每一层次结构仅仅只有O(n)个调用，这些被归纳在O(n)系数中）。结果是这个算法仅需使用O(n log n)时间。
另外一个方法是为T(n)设立一个递归关系式，也就是需要排序大小为n的数列所需要的时间。在最好的情况下，因为一个单独的快速排序调用牵涉了O(n)的工作，加上对n/2大小之数列的两个递归调用，这个关系式可以是：
T(n) = O(n) + 2T(n/2)
解决这种关系式类型的标准数学归纳法技巧告诉我们T(n) = O(n log n)。
事实上，并不需要把数列如此精确地分区；即使如果每个基准值将元素分开为99%在一边和1%在另一边，调用的深度仍然限制在100logn，所以全部运行时间依然是O(n log n)。
然而，在最坏的情况是，两子数列拥有大各为1和n-1，且调用树变成为一个n个嵌套调用的线性连串。第i次调用作了O(n-i)的工作量，且 ∑i = 0n(n – i) = O(n2)递归关系式为：
T(n) = O(n) + T(1) + T(n – 1) = O(n) + T(n – 1)
这与插入排序和选择排序有相同的关系式，以及它被解为T(n) = O(n2)。
这一段来自维基百度，读起来有点难懂，不过没有关系，直接看例子就好了。
算法稳定性
快速排序有两个方向，左边的i下标一直往右走，当a[i] <= a[center_index]，其中center_index是中枢元素的数组下标，一般取为数组第0个元素。而右边的j下标一直往左走，当a[j] > a[center_index]。如果i和j都走不动了，i <= j, 交换a[i]和a[j],重复上面的过程，直到i>j。 交换a[j]和a[center_index]，完成一趟快速排序。在中枢元素和a[j]交换的时候，很有可能把前面的元素的稳定性打乱，比如序列为 5 3 3 4 3 8 9 10 11， 现在中枢元素5和3(第5个元素，下标从1开始计)交换就会把元素3的稳定性打乱，所以快速排序是一个不稳定的排序算法，不稳定发生在中枢元素和a[j] 交换的时刻。
代码实现
<?php
function quickSort(array $numbers = array())
{
$count = count($numbers);
if ($count <= 1) return $numbers;
$left = $right = array();
$mid_value = $numbers[0];
for ($i = 1; $i < $count; ++$i) {
if($numbers[$i] < $mid_value) {
$left[] = $numbers[$i];
} else {
$right[] = $numbers[$i];
}
}
return array_merge(quickSort($left),(array)$mid_value,quickSort($right));
}
复制代码（四）、插入排序算法
插入排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置插入。插入排序在实现上，通常采用in-place排序（即只需要用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
算法步骤
从第一个元素开始，该元素可以认为已经被排序
取出下一个元素，在已经排序的元素序列中从后向前扫描
如果该元素（已排序大于新元素），将该元素移动到下一位置
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
将新元素插入到该位置后
重复步骤2~5
效率分析
如果目标是把n个元素的序列升级排序，那么采用插入排序存在最好情况和最坏情况。最好情况就是，序列已经是升序排列了，在这种情况下，需要进行的比较操作需（n-1）次即可。最坏的情况就是，序列是降序排列，那么此时需要进行的比较共有1/2 * n(n-1)次。插入排序的赋值操作是比较操作的次数加上(n-1)次。平均来说插入排序算法复杂度为O(n2)。因而，插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，例如，量级小于千，那么插入排序还是一个不错的选择。插入排序在工业级库中也有着广泛的应用，在STL的sort算法和stdlib的qsort算法中，都将插入排序作为快速排序的补充，用于少量元素的排序。
算法稳定性
插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。
代码实现
<?php
function insertSort(array $numbers = array())
{
$count = count($numbers);
if ($count <= 1) return $numbers;
for ($i = 1; $i < $count; ++$i) {
$temp = $numbers[$i];
for ($j = $i-1; $j >= 0 && $numbers[$j] > $temp; --$j) {
$numbers[$j+1] = $numbers[$j];
}
$numbers[$j+1] = $temp;
}
return $numbers;
}
复制代码（五）、希尔排序算法
希尔排序是插入排序的一种，也称缩小增加排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL.Shell于1959年提出而得名。
该方法的基本思想是：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。
算法步骤
取增量，一般取数组长度 / 2；
按增量取得一个子数列，对子数列按插入排序的方式处理；
将增量递减，重复1，2步骤；
直至增量均为0，数列已经排好序；
效率分析
希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小，插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比O(n2)好一些。
算法稳定性
希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小， 插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比O(n2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元 素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。
代码实现
<?php
function shellSort(array $numbers = array())
{
$count = count($numbers);
if ($count <= 1) return $numbers;
for ($gap = floor($count/2); $gap > 0; $gap = floor($gap/=2)) {
for($i = $gap; $i <$count; ++$i) {
for($j = $i - $gap; $j >= 0 && $numbers[$j+$gap] < $numbers[$j]; $j = $j - $gap) {
$temp = $numbers[$j];
$numbers[$j] = $numbers[$j+$gap];
$numbers[$j+$gap] = $temp;
}
}
}
return $numbers;
}
复制代码（六）、归并排序算法
归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序有，称为二路归并。
归并过程为：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。
算法步骤
申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
设定两个指针（即数组下标），最初位置分别为两个已经排序序列的起始位置；
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到一下位置；
重复步骤3直到某一指针达到序列尾；
将另一序列剩下的所有元素直接复制到合并序列尾。
效率分析
归并排序的效率是比较高的，设数列长为N，将数列分开成小数列一共要logN步，每步都是一个合并有序数列的过程，时间复杂度可以记为O(N)，故一共为O(n * logn)。因为归并排序每次都是在相邻的数据中进行操作，所以归并排序在O(N * logN)的几种排序方法（快速排序，归并排序，希尔排序，堆排序）也是效率比较高的。
算法稳定性
归并排序是把序列递归地分成短序列，递归出口是短序列只有1个元素(认为直接有序)或者2个序列(1次比较和交换),然后把各个有序的段序列合并成一个有 序的长序列，不断合并直到原序列全部排好序。可以发现，在1个或2个元素时，1个元素不会交换，2个元素如果大小相等也没有人故意交换，这不会破坏稳定 性。那么，在短的有序序列合并的过程中，稳定是是否受到破坏？没有，合并过程中我们可以保证如果两个当前元素相等时，我们把处在前面的序列的元素保存在结 果序列的前面，这样就保证了稳定性。所以，归并排序也是稳定的排序算法。
代码实现
<?php
function mergeSort(array $numbers = array())
{
$count = count($numbers);
if($count <= 1) return $numbers;
//将数组分成两份，$half = ceil($count/2)
$half = ($count >> 1) + ($count & 1);
$arr2d = array_chunk($numbers, $half);
$left = mergeSort($arr2d[0]);
$right = mergeSort($arr2d[1]);
while (count($left) && count($right)) {
if ($left[0] < $right[0]) {
$reg[] = array_shift($left);
} else {
$reg[] = array_shift($right);
}
return array_merge($reg, $left, $right);
}
}
复制代码（七）、桶排序算法
桶排序或所谓的箱排序的原理是将数组分到有限数量的桶子里，然后对每个桶子再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序），最后将各个桶中的数据有序的合并起来。
假设有一组长度为N的待排序关键字序列K[1…n]。首先将这个序列划分成M个的子区间（桶）。然后基于某种映射函数，将待排序序列的关键字K映射到第i个桶中（即桶数组B的下标i），那么该关键字k就作用B[i]中的元素（每个桶B[i]都是一组大小为N/M的序列）。接着对每个桶B[i]中的所有元素进行比较排序（可以使用快速排序）。然后依次枚举输出B[0]…B[M]中的全部内容即是一个有序序列。
映射函数：bindex = f(k) 其中，bindex 为桶数组B的下标(即第bindex个桶)，k为待排序列的关键字。桶排序之所以能够高效，其关键在于这个映射函数，它必须做到：如果关键字k1 < k2，那么f(k1) <= f(k2)。也就是说B(i)中的最小数据都要大于B(i-1)中最大数据。很显然，映射函数的确定与数据本身的特点有很大的关系，我们下面举个例子：
假如待排序列K= {49、 38 、 35、 97 、 76、 73 、 27、 49 }。这些数据全部在1—100之间。因此我们定制10个桶，然后确定映射函数f(k)=k/10。则第一个关键字49将定位到第4个桶中(49/10=4)。依次将所有关键字全部堆入桶中，并在每个非空的桶中进行快速排序后得到如下图所示：
对上图只要顺序输出每个B[i]中的数据就可以得到有序序列了。
算法步骤
假设待排序的一组数统一的分布在一个范围中，并将这一范围划分成几个子范围，也就是桶。
将待排序的一组数，分档规入这些子桶，并将桶中的数据进行排序。
将各个桶中的数据有序的合并起来。
效率分析
桶排序利用函数的映射关系，减少了几乎所有的比较工作。实际上，桶排序的f(k)值的计算，其作用就相当于快排中划分，已经把大量数据分割成了基本有序的数据块(桶)。然后只需要对桶中的少量数据做先进的比较排序即可。
对N个关键字进行桶排序的时间复杂度分为两个部分：
a )、循环计算每个关键字的桶映射函数，这个时间复杂度是O(N)。
b )、利用先进的比较排序算法对每个桶内的所有数据进行排序，其时间复杂度为∑O(Ni * logNi) 。其中 Ni为第i个桶的数据量。
很显然，第b部分是桶排序性能好坏的决定因素。尽量减少桶内数据的数量是提高效率的唯一办法(因为基于比较排序的最好平均时间复杂度只能达到O(N*logN)了)。因此，我们需要尽量做到下面两点：
a )、映射函数f(k)能够将N个数据平均的分配到M个桶中，这样每个桶就有[N/M]个数据量。
b )、尽量的增大桶的数量。极限情况下每个桶只能得到一个数据，这样就完全避开了桶内数据的“比较”排序操作。 当然，做到这一点很不容易，数据量巨大的情况下，f(k)函数会使得桶集合的数量巨大，空间浪费严重。这就是一个时间代价和空间代价的权衡问题了。
对于N个待排数据，M个桶，平均每个桶[N/M]个数据的桶排序平均时间复杂度为：O(N)+O(M*(N/M)log(N/M))=O(N+N(logN-logM)) = O(N+NlogN-NlogM)
当N=M时，即极限情况下每个桶只有一个数据时。桶排序的最好效率能够达到O(N)。
总结： 桶排序的平均时间复杂度为线性的O(N+C)，其中C=N*(logN-logM)。如果相对于同样的N，桶数量M越大，其效率越高，最好的时间复杂度达到O(N)。 当然桶排序的空间复杂度 为O(N+M)，如果输入数据非常庞大，而桶的数量也非常多，则空间代价无疑是昂贵的。
算法稳定性
桶排序中，假如升序排列，a已经在桶中，b插进来是永远都会a右边的(因为一般是从右到左，如果不小于当前元素，则插入改元素的右侧)，所以桶排序是稳定的。
代码实现
<?php
function bucketSort($max, $array)
{
//填充木桶
$arr = array_fill(0, $max+1, 0);
//开始标示木桶
for ($i = 0; $i < count($array) - 1; ++$i) {
++$arr[$array[$i]];
}
$mutong = array();
//开始从木桶中拿出数据
for ($i = 0; $i < $max; ++$i) {
for ($j = 1; $j <= $arr[$i]; ++$j) {
//这一行主要用来控制输出多个数字
$mutong[] = $i;
}
}
return $mutong;
}
复制代码（八）堆排序
堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。
/**
* 堆排序.
* heap sort algorithm.
*
* @param array $value 待排序数组 the array that is waiting for sorting
*
* @return array
*/
function heap(&$values = [])
{
//堆化数组
// the array that is simulated a heap
$heap = [];
foreach ($values as $i=>$v) {
$heap[$i] = $v;
$heap = minHeapFixUp($heap, $i);
}
$values = $heap;
//堆排序
//heap sort algorithm
$n = count($values);
for ($i = $n-1; $i>=1; $i--) {
swap($values[$i], $values[0]);
minHeapFixDown($values, 0, $i);
}
return $values;
}
function swap(&$a, &$b) {
$temp = $a;
$a= $b;
$b = $temp;
}
/**
* 堆插入数据
* the method that is used to insert data to a heap
*
* @param $values
* @param $i
* @return mixed
*/
function minHeapFixUp($values, $i) {
$j = ($i-1)/2;
$temp = $values[$i];
while($j >= 0 && $i != 0) {
if($values[$j] <= $temp) {
break;
}
$values[$i] = $values[$j];
$i = $j;
$j = ($i-1)/2;
}
$values[$i] = $temp;
return $values;
}
/**
* 调整堆,可用于删除堆节点
* to adjust heap, it can be used to remove a node of heap.
*
* @param $heap
* @param $i
* @param $n
*/
function minHeapFixDown(&$heap, $i, $n) {
$j = 2*$i + 1;
$temp = $heap[$i];
while ($j < $n) {
if($j+1 <$n && $heap[$j+1] < $heap[$j]) {
$j++;
}
if($heap[$j] >= $temp) {
break;
}
$heap[$i] = $heap[$j];
$i = $j;
$j = 2*$i + 1;
}
$heap[$i] = $temp;
}
复制代码(九)基数排序
/**
* 基数排序
*
* Least Significant Digit first
*
* 最低位优先排序
*
* @param array $value 待排序数组
*
* @return array
*/
function radix_lsd(&$value = [])
{
// 获取序列值最大位数
$max = 0;
foreach ($value as $v) {
$length = strlen((string)$v);
if ($length > $max) {
$max = $length;// 更新
}
}
unset($v);
$splice = 1;// 取最小位 初始从右往左数第一位
while ($splice <= $max) {
// 分配数字到桶中
for ($i=0; $i < 10; $i++) {
foreach ($value as $k => $v) {
$length = strlen((string)$v);
// 当前位索引位置
$index = $length-$splice;
// 不存在该位 则认为为0
if ($index < 0) {
if ($i === 0) {
$arr[0][] = $v;
}
continue;
}
$aaa = ((string)$v)[$index];
if (((string)$v)[$index] === (string)$i) {
$arr[$i][] = $v;
}
}
unset($v);
}
// 合并桶中数字
unset($value);
foreach ($arr as $tmp) {
foreach ($tmp as $v) {
$value[] = $v;
}
}
unset($tmp);
unset($v);
unset($arr);
++$splice;
}
return $value;
}
/**
* 基数排序
*
* Most Significant Digit first
*
* 最高位优先排序
*
* @param array $value 待排序数组
* @param integer $max 序列最大位数
*
* @return array
*/
function radix_msd(&$value = [], $max=0, $max_origin=0, $length_origin=0, &$origin=[], $key=0)
{
if ($max < 1) {
return;
}
// 按最高位分组，不存在当前位则认为０
$arr = [];
for ($i=0; $i < 10; $i++) {
foreach ($value as $v) {
$length = strlen((string)$v);
$index = $length - $max;
if ($index < 0) {
if ($i === 0) {
$arr[0][] = $v;
}
continue;
}
if (((string)$v)[$index] === (string)$i) {
$arr[$i][] = $v;
}
}
unset($v);
}
unset($i);
--$max;
if (!empty($origin)) {
$origin[$key] = $arr;
}else{
$value = $arr;
}
foreach ($value as $k => &$v) {
radix_msd($v, $max, $max_origin, $length_origin, $value, $k);
}
if ($max < $max_origin-1) {
return;
}
// 重新拼接
return get_value($value, $length_origin);
}
/**
* 合并排序
*
* 合并最后按个位排序完成的值
*
* @param [type] $value 排序后值
* @param integer $length 原始数组长度
* @param array $result 存放排序后数的新空间
* @return array 排序后数组
*/
function get_value($value=[], $length=0, &$result=[])
{
if (count($result) === $length) {
return;
}
foreach ($value as $k => $v) {
if (is_array($v)) {
get_value($v, $length, $result);
continue;
}
$result[] = $v;
}
return $result;
}
复制代码(十)打赏
觉得可以请小弟喝瓶矿泉水吧。嘻嘻嘻
