- 常见排序算法和时间复杂度
- 直接插入排序
- 冒泡排序
- 简单选择排序
- 希尔排序
- 快速排序
- 堆排序
- 归并排序
最差时间分析 平均时间复杂度 稳定度 空间复杂度 冒泡排序 O(n2) O(n2) 稳定 O(1) 快速排序 O(n2) O(n*log2n) 不稳定 O(log2n)~O(n) 选择排序 O(n2) O(n2) 稳定 O(1) 二叉树排序 O(n2) O(n*log2n) 不稳定 O(n) 插入排序 O(n2) O(n2) 稳定 O(1) 堆排序 O(n*log2n) O(n*log2n) 不稳定 O(1) 希尔排序 O(n²) O(n3/2) 不稳定 O(1)直接插入排序
function insertSort($arr) {
$len=count($arr);
for($i=1; $i<$len; $i++) {
$tmp = $arr[$i];
//内层循环控制，比较并插入
for($j=$i-1;$j>=0;$j--) {
if($tmp < $arr[$j]) {
//发现插入的元素要小，交换位置，将后边的元素与前面的元素互换
$arr[$j+1] = $arr[$j];
$arr[$j] = $tmp;
} else {
//如果碰到不需要移动的元素，由于是已经排序好是数组，则前面的就不需要再次比较了。
break;
}
}
}
return $arr;
}
冒泡排序
$arr=array(1,43,54,62,21,66,32,78,36,76,39);
function bubbleSort($arr)
{
$len=count($arr);
//该层循环控制 需要冒泡的轮数
for($i=1;$i<$len;$i++)
{ //该层循环用来控制每轮 冒出一个数 需要比较的次数
for($k=0;$k<$len-$i;$k++)
{
if($arr[$k]>$arr[$k+1])
{
$tmp=$arr[$k+1];
$arr[$k+1]=$arr[$k];
$arr[$k]=$tmp;
}
}
}
return $arr;
}
简单选择排序
function selectSort($arr) {
//双重循环完成，外层控制轮数，内层控制比较次数
$len=count($arr);
for($i=0; $i<$len-1; $i++) {
//先假设最小的值的位置
$p = $i;
for($j=$i+1; $j<$len; $j++) {
//$arr[$p] 是当前已知的最小值
if($arr[$p] > $arr[$j]) {
//比较，发现更小的,记录下最小值的位置；并且在下次比较时采用已知的最小值进行比较。
$p = $j;
}
}
//已经确定了当前的最小值的位置，保存到$p中。如果发现最小值的位置与当前假设的位置$i不同，则位置互换即可。
if($p != $i) {
$tmp = $arr[$p];
$arr[$p] = $arr[$i];
$arr[$i] = $tmp;
}
}
//返回最终结果
return $arr;
}
希尔排序
function shellSort($arr) {
$len = count($arr);
$k = floor($len/2);
while($k > 0) {
for($i = 0; $i < $k; $i++) {
for($j = $i; $j < $len, ($j + $k) < $len; $j = $j + $k) {
if($arr[$j] > $arr[$j+$k]) {
$tmp = $arr[$j+$k];
$arr[$j+$k] = $arr[$j];
$arr[$j] = $tmp;
}
}
}
$k = floor($k/2);
}
return $arr;
}
快速排序
function quickSort($arr) {
//先判断是否需要继续进行
$length = count($arr);
if($length <= 1) {
return $arr;
}
//选择第一个元素作为基准
$base_num = $arr[0];
//遍历除了标尺外的所有元素，按照大小关系放入两个数组内
//初始化两个数组
$left_array = array(); //小于基准的
$right_array = array(); //大于基准的
for($i=1; $i<$length; $i++) {
if($base_num > $arr[$i]) {
//放入左边数组
$left_array[] = $arr[$i];
} else {
//放入右边
$right_array[] = $arr[$i];
}
}
//再分别对左边和右边的数组进行相同的排序处理方式递归调用这个函数
$left_array = quick_sort($left_array);
$right_array = quick_sort($right_array);
//合并
return array_merge($left_array, array($base_num), $right_array);
}
堆排序
// 调整子堆的为大根堆的过程， s 为 子 堆 的 根 的 位 置 ， s为子堆的根的位置， s为子堆的根的位置，m为堆最后一个元素位置
function heapAdjust(&$arr, $s, $m) {
$tmp = $arr[$s];
// 在调整为大根堆的过程中可能会影响左子堆或右子堆
// for循环的作用是要保证子堆也是大根堆
for($j = 2*$s + 1; $j <= $m; $j = 2*$j + 1) {
// 找到根节点的左右孩子中的最大者，然后用这个最大者与根节点比较，
// 若大则进行调整，否则符合大根堆的 特点跳出循环
if($j < $m && $arr[$j] < $arr[$j+1]) {
$j++;
}
if($tmp >= $arr[$j] ) {
break;
}
$arr[$s] = $arr[$j];
$s = $j;
}
$arr[$s] = $tmp;
}
// 堆排序
function heapSort($arr) {
$len = count($arr);
// 依次从子堆开始调整堆为大根堆
for($i = floor($len/2-1); $i >= 0; $i--) {
heapAdjust($arr, $i, $len-1);
}
// 依次把根节点调换至最后一个位置，再次调整堆为大根堆，找到次最大值，
// 依次类推得到一个有序数组
for($n = $len-1; $n > 0; $n--) {
$tmp = $arr[$n];
$arr[$n] = $arr[0];
$arr[0] = $tmp;
heapAdjust($arr, 0, $n-1);
}
return $arr;
}
归并排序
// 分别将有序的$arr1[s..m]、$arr2[m+1..n]归并为有序的$arr2[s..n]
function Merge(&$arr1, &$arr2, $s, $m, $n) {
for($k = $s,$i = $s, $j = $m+1; $i <= $m && $j <= $n; $k++) {
if($arr1[$i]<$arr1[$j]) {
$arr2[$k] = $arr1[$i++];
}else {
$arr2[$k] = $arr1[$j++];
}
}
if($i <= $m) {
for(; $i <= $m; $i++) {
$arr2[$k++] = $arr1[$i];
}
} else if($j <= $n) {
for(; $j <= $n; $j++) {
$arr2[$k++] = $arr1[$j];
}
}
}
// 递归形式的两路归并
function MSort(&$arr1, &$arr2, $s, $t) {
if($s == $t) {
$arr2[$s] = $arr1[$s];
}else {
$m = floor(($s+$t)/2);
$tmp_arr = array();
MSort($arr1, $tmp_arr, $s, $m);
MSort($arr1, $tmp_arr, $m+1, $t);
Merge($tmp_arr, $arr2, $s, $m, $t);
}
}
// 对一位数组$arr[0..n-1]中的元素进行两路归并
function mergeSort($arr) {
$len = count($arr);
MSort($arr, $arr, 0, $len-1);
return $arr;
}
