PHP常用排序算法实例小结【基本排序，冒泡排序，快速排序，插入排序】

php三种基础算法：冒泡，插入和快速排序法$array=array(2,3,5,6,9,8,1);//冒泡排序思想，前后元素

php三种基础算法：冒泡，插入和快速排序法

$array = array(2,3,5,6,9,8,1);

//冒泡排序思想，前后元素比较
function sort_bulldle($array){
 $num = count($array);
 for($i=0; $i<$num; $i++){
 $tmp = $array[$i];
 for ($j=$i-1; $j>=0; $j--) {
 if ($tmp < $array[$j]) {
 $arr[$j+1] = $arr[$j];
 $arr[$j] = $tmp;
 } else {
 break;
 }
 }
 }
 return $array;
}

//插入排序思想，就是从第二个元素开始，到最后一个元素都是这个需要排序的元素
function sort_bulldle($arr){
 for($i=1, $len=count($arr); $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;
}

//快速排序，找一个基准点把数组分成两组比较
function sort_bulldle($array){
 $num = count($array);
 if($num<=1) {
 return $array;
 }
 $base_num = $array[0];
 $left_array = array();
 $right_array = array();
 for($i=1; $i<$num; $i++) {
 if ($base_num > $array[$i]) {
 $left_array[] = $array[$i];
 }else
 {
 $right_array[] = $array[$i];
 }
 }
 $left_array = sort_bulldle($left_array);
 $right_array = sort_bulldle($right_array);
 return array_merge($left_array, array($base_num), $right_array);
}

本文实例总结了PHP常用排序算法。分享给大家供大家参考，具体如下：

class bevin{
public $public = 'public';
private $private = 'private';
protected $protected = 'protected';
//final $final = 'final';
static $static = 'static';
function __construct(){
 $this->protected = 'change private';
}
public function setValue($a){
 self::$static = $a;
}
public function getValue(){
 echo $this->private;
}
function __destruct(){
 echo 'asdfsadf';
}
}
class paixu {
// 基本排序
public function t_sortArray($array) {
 if(is_array($array) && count($array)>1) {
 for($i=0; $i<count($array); $i++) {
 for($j=($i+1); $j<count($array); $j++) {
 $temp = $array[$i];
 if($array[$j]<$array[$i]) {
 $array[$i] = $array[$j];
 $array[$j] = $temp;
 }
 }
 }
 return $array;
 } else {
 return $array;
 }
}
// 冒泡排序
public function c_sortArray($array) {
 if(!is_array($array) || count($array)<=1){ return $array; }
 $status = false;
 foreach($array as $key=>$v) {
 if($key>0) {
 if($array[$key-1]>$array[$key]) {
 $array[$key] = $array[$key-1];
 $array[$key-1] = $v;
 $status = true;
 }
 }
 }
 if($status) {
 return $this->c_sortArray($array);
 } else {
 return $array;
 }
}
// 快速排序
public function v_sortArray($array) {
 if(!is_array($array) || count($array)<=1){ return $array; }
 if(count($array)>2) {
 $m = $array[floor(count($array)/2)+1];
 } else {
 if($array[0]>$array[1]) {
 $temp = $array[0];
 $array[0] = $array[1];
 $array[1] = $temp;
 }
 return $array;
 }
 $leftarray = array();
 $rightarray = array();
 foreach($array as $key=>$v) {
 if($v>$m) {
 $rightarray[] = $v;
 }
 if($v<$m) {
 $leftarray[] = $v;
 }
 if($v==$m) {
 $mid[] = $v;
 }
 }
 $nleftarray = $this->v_sortArray($leftarray);
 $nrightarray = $this->v_sortArray($rightarray);
 return array_merge($nleftarray,$mid,$nrightarray);
}
// 直接插入排序
public function i_sortArray($array) {
 if(!is_array($array) || count($array)<=1){ return $array; }
 $newarray = array($array[0]);
 $temp = 0;
 foreach($array as $k=>$v) {
 if($k>0) {
 if($v>=$newarray[count($newarray)-1]) {
 $newarray[] = $v;
 } else {
 foreach($newarray as $nk=>$nv) {
 if($v<$nv) {
 $temparray = array();
 foreach($newarray as $ck=>$cv) {
 if($ck<$nk) {
 $temparray[$ck] = $cv;
 } elseif($ck==$nk) {
 $temparray[$ck] = $v;
 $temparray[($ck+1)] = $cv;
 } else {
 $temparray[($ck+1)] = $cv;
 }
 }
 $newarray = $temparray;
 break;
 }
 }
 }
 }
 }
 return $newarray;
}
}
$bevin = new paixu;
$array = array(5,4,5,4,4,5,5,5,5,5);
$v = $bevin->t_sortArray($array);
print_r($v);
$v = $bevin->c_sortArray($array);
print_r($v);
$v = $bevin->v_sortArray($array);
print_r($v);
$v = $bevin->i_sortArray($array);
print_r($v);

运行结果：

Array
(
 [0] => 4
 [1] => 4
 [2] => 4
 [3] => 5
 [4] => 5
 [5] => 5
 [6] => 5
 [7] => 5
 [8] => 5
 [9] => 5
)
Array
(
 [0] => 4
 [1] => 4
 [2] => 4
 [3] => 5
 [4] => 5
 [5] => 5
 [6] => 5
 [7] => 5
 [8] => 5
 [9] => 5
)
Array
(
 [0] => 4
 [1] => 4
 [2] => 4
 [3] => 5
 [4] => 5
 [5] => 5
 [6] => 5
 [7] => 5
 [8] => 5
 [9] => 5
)
Array
(
 [0] => 4
 [1] => 4
 [2] => 4
 [3] => 5
 [4] => 5
 [5] => 5
 [6] => 5
 [7] => 5
 [8] => 5
 [9] => 5
)