排序算法经过了很长时间的演变，产生了很多种不同的方法。对于初学者来说，对它们进行整理便于理解记忆显得很重要。每种算法都有它特定的使用场合，很难通用。因此，我们很有必要对所有常见的排序算法进行归纳。
排序大的分类可以分为两种：内排序和外排序。在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使用外存，则称为外排序。下面讲的排序都是属于内排序。
内排序有可以分为以下几类：
(1)、插入排序：直接插入排序、shell排序、折半插入排序。
(2)、选择排序：直接选择排序、堆排序。
(3)、交换排序：冒泡排序、快速排序。
(4)、归并排序
(5)、桶式排序
(6)、基数排序
表格版
| 排序方法 | 时间复杂度（平均） | 时间复杂度（最坏) | 时间复杂度（最好) | 空间复杂度 | 稳定性 | 复杂性 |
|---|---|---|---|---|---|---|
| 直接插入排序 | O(n2)O(n2) | O(n2)O(n2) | O(n)O(n) | O(1)O(1) | 稳定 | 简单 |
| 希尔排序 | O(nlog2n)O(nlog2n) | O(n2)O(n2) | O(n)O(n) | O(1)O(1) | 不稳定 | 较复杂 |
| 直接选择排序 | O(n2)O(n2) | O(n2)O(n2) | O(n2)O(n2) | O(1)O(1) | 不稳定 | 简单 |
| 堆排序 | O(nlog2n)O(nlog2n) | O(nlog2n)O(nlog2n) | O(nlog2n)O(nlog2n) | O(1)O(1) | 不稳定 | 较复杂 |
| 冒泡排序 | O(n2)O(n2) | O(n2)O(n2) | O(n)O(n) | O(1)O(1) | 稳定 | 简单 |
| 快速排序 | O(nlog2n)O(nlog2n) | O(n2)O(n2) | O(nlog2n)O(nlog2n) | O(nlog2n)O(nlog2n) | 不稳定 | 较复杂 |
| 归并排序 | O(nlog2n)O(nlog2n) | O(nlog2n)O(nlog2n) | O(nlog2n)O(nlog2n) | O(n)O(n) | 稳定 | 较复杂 |
| 基数排序 | O(d(n+r))O(d(n+r)) | O(d(n+r))O(d(n+r)) | O(d(n+r))O(d(n+r)) | O(n+r)O(n+r) | 稳定 | 较复杂 |
① 插入排序
•思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置，直到全部插入排序完为止。
•关键问题：在前面已经排好序的序列中找到合适的插入位置。
•方法：
–直接插入排序
–二分插入排序
–希尔排序
(1)直接插入排序（从后向前找到合适位置后插入）
基本思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置（从后向前找到合适位置后），直到全部插入排序完为止。
$arr = [8,6,9,20,5,3];
function directInsertSort($arr) {
$len = count($arr);
for($i=1; $i<$len; $i++) { //待排序的元素
$tmp = $arr[$i];
for($j=$i-1; $j>=0; $j--) { //前边已经排序好的元素
if($tmp >= $arr[$j]) { //减少循环次数
break;
} else { //置换
$arr[$j+1] = $arr[$j];
$arr[$j] = $tmp;
}
}
}
return $arr;
}
var_dump(directInsertSort($arr));die;
（2）希尔排序
基本思想：先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1，即所有记录放在同一组中进行直接插入排序为止。(实际上就是一个分组插入排序，先对数据分组，然后对每个分组做插入排序)
function shellSort($arr) {
$len = $d = count($arr);
while($d>1) {
$d = ceil($d/2); //步长
//直接插入排序
for($i=$d; $i<$len; $i+=$d) {
$tmp = $arr[$i];
for($j= $i-$d; $j>=0; $j-=$d) {
if($tmp >= $arr[$j]) { //减少内部循环次数
break;
} else {
$arr[$j+$d] = $arr[$j];
$arr[$j] = $tmp;
}
}
}
}
return $arr;
}
var_dump(shellSort($arr));
② 选择排序
(1)直接选择排序
基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
function selectSort($arr) {
$len = count($arr);
for($i=0; $i<$len; $i++) {
$pos = $i; //记录最小值位置，避免内部循环中多次置位
for($j=$i+1; $j<$len; $j++) {
if($arr[$j] < $arr[$pos]) {
$pos = $j;
}
}
if($pos != $i) {
$tmp = $arr[$i];
$arr[$i] = $arr[$pos];
$arr[$pos] = $tmp;
}
}
return $arr;
}
var_dump(selectSort($arr));
(2)堆排序
1、基本思想：
堆排序是一种树形选择排序，是对直接选择排序的有效改进。
堆的定义下：具有n个元素的序列 （h1,h2,…,hn),当且仅当满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1） (i=1,2,…,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。完全二叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。
思想：初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。
function buildMaxHeap(&$arr)
{
global $len;
for ($i = floor($len/2); $i >= 0; $i--) {
heapify($arr, $i);
}
}
function heapify(&$arr, $i)
{
global $len;
$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)
{
$temp = $arr[$i];
$arr[$i] = $arr[$j];
$arr[$j] = $temp;
}
function heapSort($arr) {
global $len;
$len = count($arr);
buildMaxHeap($arr);
for ($i = count($arr) - 1; $i > 0; $i--) {
swap($arr, 0, $i);
$len--;
heapify($arr, 0);
}
return $arr;
}
var_dump(heapSort($arr));
③ 交换排序
(1)冒泡排序
1、基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。
//下沉
function sinkBubbleSort($arr) {
$len = count($arr);
for($i=0; $i<$len; $i++) { //共进行$len次（轮）冒泡
$swapFlag = false; //标记是否置换
for($j=0; $j<$len-$i-1; $j++) { //下沉，控制$j的最大位置，因为最下边的$i个已经完成排序。正着循环，因为可以节省下边已经排好序的循环。
if($arr[$j] > $arr[$j+1]) {
$swapFlag = true;
$tmp = $arr[$j];
$arr[$j] = $arr[$j+1];
$arr[$j+1] = $tmp;
}
}
if(!$swapFlag) { //如果没有置换发生，说明已是一个有序数组
return $arr;
}
}
return $arr;
}
var_dump(sinkBubbleSort($arr));
//上浮
function goUpBubbleSort($arr) {
$len = count($arr);
for($i=0; $i<$len-1; $i++) { //共进行$len次（轮）冒泡
$swapFlag = false; //标记是否置换
for($j=$len-1; $j>$i; $j--) { //下沉，控制$j的最小位置，因为最上边$i个已经完成排序。倒着循环，因为可以节省上边已经排好序的循环
if($arr[$j] > $arr[$j-1]) {
$swapFlag = true;
$tmp = $arr[$j];
$arr[$j] = $arr[$j-1];
$arr[$j-1] = $tmp;
}
}
if(!$swapFlag) {
return $arr;
}
}
return $arr;
}
var_dump(goUpBubbleSort($arr));
(2)快速排序
1、基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。
function quickSort($arr) {
$len = count($arr);
if($len <= 1) {
return $arr;
}
$base = $arr[0]; //选取一个基准值
$left = $right = [];
for($i=1; $i<$len; $i++) { //除去基准值
if($arr[$i] < $base) { //小于基准值
$left[] = $arr[$i];
} else { //不小于基准值
$right[] = $arr[$i];
}
}
//递归调用
$left = quickSort($left);
$right = quickSort($right);
return array_merge($left, [$base], $right);
}
var_dump(quickSort($arr));
④ 归并排序
1、基本思想:归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
function merge($left, $right) {
$result = [];
while(count($left) > 0 && count($right) > 0) {
if($left[0] > $right[0]) {
$result[] = array_shift($right);
} else {
$result[] = array_shift($left);
}
}
while(count($left) > 0) {
$result[] = array_shift($left);
}
while(count($right) > 0) {
$result[] = array_shift($right);
}
return $result;
}
function mergeSort($arr) {
$len = count($arr);
if($len <= 1) {
return $arr;
}
$middle = floor($len/2);
$left = array_slice($arr, 0, $middle);
$right = array_slice($arr, $middle);
return merge(mergeSort($left), mergeSort($right));
}
var_dump(mergeSort($arr));
12万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
