php排序算法?php排序经典算法

 代码如下 复制代码

1.冒泡算法,排序算法，由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序

$array = array(a,f,c,b,e,h,j,i,g); 

   function maopao_fun($array){ 

       if($len <= 1) { 

           return $arr; 

       } 

       $count = count($array); 

       for($i=0;$i<$count;$i++){ 

           for($j=$count-1;$j>$i;$j--){ 

               if($array[$j] > $array[$j-1]){ 

                   $tmp = $array[$j]; 

                   $array[$j] = $array[$j-1]; 

                   $array[$j-1] = $tmp; 

               } 

           } 

       } 

       return $array; 

   } 

2.快速排序,
快速排序（Quicksort）是对冒泡排序的一种改进。
由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，
其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，
整个排序过程可以递归进行，以此达到整个数据变成有序序列。

function quickSort($arr){ 

       $len = count($arr); 

       if($len <= 1) { 

           return $arr; 

       } 

       $key = $arr[0]; 

       $left_arr    = array(); 

       $right_arr    = array(); 

       for($i=1; $i<$len; $i++){ 

           if($arr[$i] <= $key){ 

               $left_arr[] = $arr[$i]; 

           } else { 

               $right_arr[] = $arr[$i]; 

           } 

       } 

       $left_arr    = quickSort($left_arr); 

       $right_arr    = quickSort($right_arr); 

       return array_merge($left_arr, array($key), $right_arr); 

   } 

3.选择排序
每一趟从待排序的数据元素中选出最小（或最大）的一个元素，
顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法

 代码如下 复制代码

function select_sort($arr){ 

    $count = count($arr); 

    for($i=0; $i<$count; $i++){ 

        for($j=$i+1; $j<$count; $j++){ 

            if ($arr[$i] > $arr[$j]){ 

                $tmp = $arr[$i]; 

                $arr[$i] = $arr[$j]; 

                $arr[$j] = $tmp; 

            } 

        } 

    } 

    return $arr; 

} 

4.插入排序
　 从第一个元素开始，该元素可以认为已经被排序
　 取出下一个元素，在已经排序的元素序列中从后向前扫描
　 如果该元素（已排序）大于新元素，将该元素移到下一位置
　 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
　 将新元素插入到下一位置中
　 重复步骤2

 代码如下 复制代码

function insert_sort($arr){ 

        $count = count($arr); 

        for($i=1; $i<$count; $i++){ 

            $tmp = $arr[$i]; 

            $j = $i - 1; 

            while($arr[$j] > $tmp){ 

                $arr[$j+1] = $arr[$j]; 

                $arr[$j] = $tmp; 

                $j--; 

            } 

        } 

        return $arr; 

    } 

  

    $arr = array(49,38,65,97,76,13,27); 

    print_r(insert_sort($arr));

 

四种排序算法的PHP实现

1) 插入排序(Insertion Sort)的基本思想是：
每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子文件中的适当位置，直到全部记录插入完成为止。
2) 选择排序(Selection Sort)的基本思想是：
每一趟从待排序的记录中选出关键字最小的记录，顺序放在已排好序的子文件的最后，直到全部记录排序完毕。
3) 冒泡排序的基本思想是：
两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。
4) 快速排序实质上和冒泡排序一样，都是属于交换排序的一种应用。所以基本思想和上面的冒泡排序是一样的。

 代码如下 复制代码

<?php
/**
 * 四种排序算法设计（PHP）
 *
 * 1) 插入排序(Insertion Sort)的基本思想是：
   每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子文件中的适当位置，直到全部记录插入完成为止。
   2) 选择排序(Selection Sort)的基本思想是：
      每一趟从待排序的记录中选出关键字最小的记录，顺序放在已排好序的子文件的最后，直到全部记录排序完毕。
   3) 冒泡排序的基本思想是：
      两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。
   4) 快速排序实质上和冒泡排序一样，都是属于交换排序的一种应用。所以基本思想和上面的冒泡排序是一样的。
 *
 * @author quanshuidingdang
 */
class Sort {
 private $arr  = array(); 
 private $sort = 'insert';
 private $marker = '_sort';
 
 private $debug = TRUE;
 
 /**
  * 构造函数
  *
  * @param array 例如： $config = array (
         'arr' => array(22,3,41,18) ,  //需要排序的数组值
         'sort' => 'insert',      //可能值: insert, select, bubble, quick
         'debug' => TRUE        //可能值: TRUE, FALSE
         )
  */
 public function __construct($config = array()) {
  if ( count($config) > 0) {
   $this->_init($config);
  }
 }
 
 /**
  * 获取排序结果
  */
 public function display() {
  return $this->arr;
 }
 
 /**
  * 初始化
  *
  * @param array
  * @return  bool
  */
 private function _init($config = array()) {
  //参数判断
  if ( !is_array($config) OR count($config) == 0) {
   if ($this->debug === TRUE) {
    $this->_log("sort_init_param_invaild");
   }
   return FALSE;
  }
  
  //初始化成员变量
  foreach ($config as $key => $val) {
   if ( isset($this->$key)) {
    $this->$key = $val;
   }
  }
  
  //调用相应的成员方法完成排序
  $method = $this->sort . $this->marker;
  if ( ! method_exists($this, $method)) {
   if ($this->debug === TRUE) {
    $this->_log("sort_method_invaild");
   }
   return FALSE;
  }
  
  if ( FALSE === ($this->arr = $this->$method($this->arr)))
   return FALSE;
  return TRUE;
 }
 
 /**
  * 插入排序
  *
  * @param array
  * @return bool
  */
 private function insert_sort($arr) {
  //参数判断
  if ( ! is_array($arr) OR count($arr) == 0) {
   if ($this->debug === TRUE) {
    $this->_log("sort_array(insert)_invaild");
   }
   return FALSE;
  }
  
  //具体实现
  $count = count($arr);
  for ($i = 1; $i < $count; $i++) {
   $tmp = $arr[$i];
   for($j = $i-1; $j >= 0; $j--) { 
    if($arr[$j] > $tmp) {
     $arr[$j+1] = $arr[$j];
     $arr[$j] = $tmp;
    }
   }
  }
  return $arr;
 }
 
 /**
  * 选择排序
  *
  * @param array
  * @return bool
  */
 private function select_sort($arr) {
  //参数判断
  if ( ! is_array($arr) OR count($arr) == 0) {
   if ($this->debug === TRUE) {
    $this->_log("sort_array(select)_invaild");
   }
   return FALSE;
  }
  
  //具体实现
  $count = count($arr);
  for ($i = 0; $i < $count-1; $i++) {
   $min = $i;
   for ($j = $i+1; $j < $count; $j++) {
    if ($arr[$min] > $arr[$j])  $min = $j;
   }
   if ($min != $i) {
    $tmp = $arr[$min];
    $arr[$min] = $arr[$i];
    $arr[$i] = $tmp;
   }
  }
  return $arr;
 }
 
 /**
  * 冒泡排序
  *
  * @param array
  * @return bool
  */
 private function bubble_sort($arr) {
  //参数判断
  if ( ! is_array($arr) OR count($arr) == 0) {
   if ($this->debug === TRUE) {
    $this->_log("sort_array(bubble)_invaild");
   }
   return FALSE;
  }
  
  //具体实现
  $count = count($arr);
  for ($i = 0; $i < $count; $i++) {
   for ($j = $count-1; $j > $i; $j--) {
    if ($arr[$j] < $arr[$j-1]) {
     $tmp = $arr[$j];
     $arr[$j] = $arr[$j-1];
     $arr[$j-1] = $tmp;
    }
   }
  }
  return $arr; 
 }
 
 /**
  * 快速排序
  *
  * @param array
  * @return bool
  */
 private function quick_sort($arr) {
  //具体实现
  if (count($arr) <= 1) return $arr;
  $key = $arr[0];
  $left_arr = array();
  $right_arr = array();
  for ($i = 1; $i < count($arr); $i++){
   if ($arr[$i] <= $key)
    $left_arr[] = $arr[$i];
   else
    $right_arr[] = $arr[$i];
  }
  $left_arr = $this->quick_sort($left_arr);
  $right_arr = $this->quick_sort($right_arr);

  return array_merge($left_arr, array($key), $right_arr);
 }
 
 /**
  * 日志记录
  */
 private function _log($msg) {
  $msg = 'date[' . date('Y-m-d H:i:s') . '] ' . $msg . 'n';
  return @file_put_contents('sort_err.log', $msg, FILE_APPEND);
 }
}

/*End of file sort.php*/
/*Location htdocs/sort.php */
时间： 2024-10-29 12:04:46

php排序算法?php排序经典算法的相关文章

php中实现冒泡排序、快速排序、选择排序和插入排序等经典算法

// 冒泡排序 function BubbleSort($arr) { // 获得数组总长度 $num = count($arr); // 正向遍历数组 for ($i = 1; $i < $num; $i++) { // 反向遍历 for ($j = $num - 1; $j >= $i ; $j--) { // 相邻两个数比较 if ($arr[$j] < $arr[$j-1]) { // 暂存较小的数 $iTemp = $arr[$j-1]; // 把较大的放前面 $arr[$j-

数据结构经典算法

C#选择排序 using System:namespace SelectionSorter{ public class SelectionSorter{ private int min:public void Sort(int [] list){ for(int i=0:i<list.Length-1:i++){ min=i:for(int j=i+1:j<list.Length:j++){ if(list[j]<list[min])min=j:}int t=list[min]:list

php经典算法集锦_php技巧

本文实例讲述了php几个经典算法.分享给大家供大家参考,具体如下: 有5个人偷了一堆苹果,准备在第二天分赃.晚上,有一人遛出来,把所有菜果分成5份,但是多了一个,顺手把这个扔给树上的猴了,自己先拿1/5藏了.没想到其他四人也都是这么想的,都如第一个人一样分成5份把多的那一个扔给了猴,偷走了1/5.第二天,大家分赃,也是分成5份多一个扔给猴了.最后一人分了一份.问:共有多少苹果? for ($i = 1; ; $i++) { if ($i%5 == 1) { //第一个人取五分之一,还剩$t $t

经典算法(8) MoreWindows白话经典算法之七大排序总结篇

在我的博客对冒泡排序,直接插入排序,直接选择排序,希尔排序,归并排序,快速排序和堆排序这七种 常用的排序方法进行了详细的讲解,并做成了电子书以供大家下载.下载地址为: http://download.csdn.net/detail/morewindows/4443208. 有网友提议到 这本<MoreWindows白话经典算法之七大排序>电子书讲解细致用来平时学习是非常好的,但是页数有22页, 不太合适做面试前的复习资料.因此在这里将这七种常用的排序方法进行下总结,以便大家更好的复习这些 经典

经典算法(3) 希尔排序的实现

希尔排序的实质就是分组插入排序,该方法又称缩小增量排序,因DL．Shell于1959年提出而得名. 该方法的基本思想是:先将整个待排元素序列分割成若干个子序列(由相隔某个"增量"的元素组成 的)分别进行直接插入排序,然后依次缩减增量再进行排序,待整个序列中的元素基本有序(增量足够小) 时,再对全体元素进行一次直接插入排序.因为直接插入排序在元素基本有序的情况下(接近最好情况), 效率是很高的,因此希尔排序在时间效率上比前两种方法有较大提高. 以n=10的一个数组49, 38, 65,

算法速成（二）七大经典排序之选择排序

今天说的是选择排序,包括"直接选择排序"和"堆排序". 话说上次"冒泡排序"被快 排虐了,而且"快排"赢得了内库的重用,众兄弟自然眼红,非要找快排一比高下. 这不今天 就来了两兄弟找快排算账. 1.直接选择排序: 先上图: 说实话,直接选择排序最类似于人的本能思想,比如把大小不一的玩具让三岁小毛孩对大小 排个序, 那小孩首先会在这么多玩具中找到最小的放在第一位,然后找到次小的放在第二位, 以此类推...... ,小 孩子多聪明

经典算法题每日演练——第二十三题 鸡尾酒排序

原文:经典算法题每日演练--第二十三题 鸡尾酒排序     这篇我们继续扯淡一下鸡尾酒排序,为了知道为啥取名为鸡尾酒,特意看了下百科,见框框的话,也只能勉强这么说了.   要是文艺点的话,可以说是搅拌排序,通俗易懂点的话,就叫"双向冒泡排序",我想作为码农的话,不可能不知道冒泡排序, 冒泡是一个单向的从小到大或者从大到小的交换排序,而鸡尾酒排序是双向的,从一端进行从小到大排序,从另一端进行从大 到小排序. 从图中可以看到,第一次正向比较,我们找到了最大值9.             

经典算法题每日演练——第二十二题 奇偶排序

原文:经典算法题每日演练--第二十二题 奇偶排序   这个专题因为各种原因好久没有继续下去了,MM吧...你懂的,嘿嘿,不过还得继续写下去,好长时间不写,有些东西有点生疏了, 这篇就从简单一点的一个"奇偶排序"说起吧,不过这个排序还是蛮有意思的,严格来说复杂度是O(N2),不过在多核的情况下,可以做到 N2 /(m/2)的效率,这里的m就是待排序的个数,当m=100,复杂度为N2 /50,还行把,比冒泡要好点,因为重点是解决问题的奇思妙想.     下面我们看看这个算法是怎么描述的,既

经典算法题每日演练——第二十四题 梳排序

这篇再看看一个经典的排序,梳排序,为什么取名为梳,可能每个梳都有自己的gap吧,大梳子gap大一点,小梳子gap小一点. 上一篇我们看到鸡尾酒排序是在冒泡排序上做了一些优化,将单向的比较变成了双向,同样这里的梳排序也是在冒泡排序上做了一些优化. 冒泡排序上我们的选择是相邻的两个数做比较,就是他们的gap为1,其实梳排序提出了不同的观点,如果将这里的gap设置为一定的大小, 效率反而必gap=1要高效的多. 下面我们看看具体思想,梳排序有这样一个1.3的比率值,每趟比较完后,都会用这个1.3去递减

经典算法-C#四种排序算法

排序|算法 本文介绍了C#的四种排序算法:冒泡排序.选择排序.插入排序和希尔排序 冒泡排序 using System: namespace BubbleSorter { public class BubbleSorter { public void Sort(int [] list) { int i,j,temp: bool done=false: j=1: while((j<list.Length)&&(!done)) { done=true: for(i=0:i<list.