php随机数组冒泡排序（php数组从大到小排序谁帮忙想下感谢）

本文目录

• php数组从大到小排序谁帮忙想下感谢
• 用PHP编写程序
• PHP For 循环 怎么能把 数组 从小到大排列呢
• 用php程序编写冒泡排序、快速排序
• 使用php语言编写代码,定义一个数组,填充10个100以内随机数,并按从小到大的顺
• 常见的php排序算法
• php几种排序算法实例详解
• 用php写出代码：3，6，7，1，8，2，9，4，5，0按照从小到大的顺序输出数组的值

php数组从大到小排序谁帮忙想下感谢

• 你好，建议使用冒泡排序法，这样看上去比较清楚明了，你这样编写就比较复杂了。

• 判断1和2的大小，如果2大，则调换1和2的值。拿判断处理之后的2值跟3值比。这样循环到4和5比。会把最小值换到5(前面的值没有正确顺序）。

  这个时候，我们只需要再重复一次，就能把第二小的值放到4。同理再重复到3，到2.就把5个值的大小理顺了。

  放到代码力，就是一个双重循环，例如：

用PHP编写程序

PHP可以使用sort()函数以升序对数组排序。请看以下代码：

《?php 
$a = array(8,2,7,5,1);
$a = sort($a);
echo $a;
?》

PHP For 循环 怎么能把 数组 从小到大排列呢

　　用非常典型的冒泡排序即可实现，具体实现思路如下列代码所示：

《?php 
    //首先定义一个数组；
    $arr=array(100,23,69,2,50,31);
    //计算数组的长度；
    $length =count($arr);
    //外层循环n-1
    for($n=0;$n《$length-1;$n++){
        //内层循环n-i-1
         for($i=0;$i《$length-$n-1;$i++){
             //判断数组元素大小，交换位置，实现从小往大排序
            if($arr){
                $temp=$arr;
                $arr;
                $arr=$temp; 
             }
            
         }
        
    }
    print_r($arr);
    //Array (  =》 100 ) 
    
?》

用php程序编写冒泡排序、快速排序

不要做这些作业，如果你想学好PHP的话，因为PHP有更高效的函数可以直接调用完成排序，对于学习PHP来说，知道系统函数并熟练调用才是能力，冒泡法这样的浪费光阴的东西，不可能在任何一个PHP项目中使用。

使用php语言编写代码,定义一个数组,填充10个100以内随机数,并按从小到大的顺

因为语言不同，代码就不贴了，思路如下：
定义数组，因为10个是确定的，所以用第一个for循环循环十次，每次都random出数字赋值给数组，之后冒泡排序，因为冒泡法的循环次数不定，用while内嵌for循环：
while(flag){
flag=false;
for(i=0;i《10;i++)
{if(a;flag=true;}}
}
意思就是每次都用冒泡法给a0~a9两两排序，如果确实有不符合要求的就变动位置，如果都没有那么flag保持初值false则推出while循环

常见的php排序算法

常见的php排序算法

　　本文汇总了常见的php排序算法，在进行算法设计的时候有不错的借鉴价值。现分享给大家供参考之用。具体如下：

　　 一、插入排序

　　用文字简单的描述，比如说$arr = array(4,2,4,6,3,6,1,7,9); 这样的一组数字进行顺序排序：

　　那么，首先，拿数组的第二个元素和第一元素比较，假如第一个元素大于第二元素，那么就让两者位置互换，接下来，拿数组的第三个元素，分别和第二个，第一个元素比较，假如第三个元素小，那么就互换。依次类推。这就是插入排序,它的时间频度是：1+2+...+(n-1)=(n^2)/2。则它的时间复杂度为O(n^2).

　　php实现代码如下：

　　《?phpfunction Sort($arr){ $count = count($arr); if($count《2){ return $arr; } for($i=1;$i《$count;$i++){ tmp="$arr){ return=""》

　　 二、选择排序

　　选择排序用语言描述的话，可以这样,如：$arr = array(4,3,5,2,1);

　　首先,拿第一个和后面所有的比，找出最小的那个数字，然后和第一个数组互换（当然，如果是第一个最小，那么就不用互换了），接着循环，即：拿第二个和后面的比较，找出最小的数字，然后和第二个数字互换，依次类推，也就是说每次都是找出剩余最小的值。 可得到：第一次，时间频度 是n, （第一个和后面的n－1个比较，找到最小的，再看是不是第一个，不是第一个的话进行互换） 在往后，依次是 减一 。 它的时间复杂度，也是O(n^2);

　　php实现代码如下：

　　《?phpfunction selectSort($arr){ $count = count($arr); if($count《2){ return $arr; } for($i=0;$i《$count;$i++){ $min=$i; for(j=$i+1;$j《$count;$j++){》$arr = $tmp; } } return $arr; }?》

　　 三、冒泡排序

　　冒泡排序其实上是和选择排序相比，并无明显差别。都是找到最小的，放到最左端。依次循环解决问题。差别在于冒泡排序的交换位置的次数较多，而选择排序则是找到最小的元素的下标，然后直接和最左端的交换位置。

　　php实现代码如下：

　　《?phpfunction selectSort($arr){ $count = count($arr); if($count《2){ return $arr; } for($i=0;$i《$count;$i++){ for(j=$i+1;$j《$count;$j++){》$arr = $tmp; } } } return $arr; }?》

　　 四、快速排序

　　快速排序，用语言来形容的话，从数组中选择一个值$a，然后和其余元素进行比较，比$a大的放到数组right中，反之，放到数组left中。然后将left right 分别进行递归调用，即：再细分left right ，最后进行数组的合并。

　　php实现快速排序：

　　《?phpfunction mySort($arr){ $count = count($arr); if($count《2){ return $arr; } $key = $arr; } } $left = mySort($left); $right = mySort($right); $result = array_merge($left,$right); return $result; }?》

　　 五、归并排序

　　其实归并排序是一种拆分，合并的思想。和快速排序思想有共通之处，左边一堆，右边一堆，然后进行合并。通过递归实现排序。 区别之处呢？ 他们的区别也是思想上本质的区别，快速排序的拆分，是选择了特定的值进行大小比较，从而分为left 和 right 。也就是小的一堆放入left，大的一堆放入right。而后，小的left 再细分为left1 right1。。。。通过进行类似的递归完成排序。也就是说，一直细分下去，递归最末尾的left1就是最小值。

　　而归并排序，是从几何上的左右切分，一直递归切分成2或者1的’最小粒度的数组，然后才开始进行比较大小，然后合并。此处的比较大小是：儿子left的元素 和儿子的right元素 进行比较，而后进行排序合并成为父亲left或者right。在此，直到拿到各自排序合并完成最后两个数组：最起初的left 和right，也仅仅直到他们各自的顺序，并不能确认整个数组的顺序，还是需要通过最终的left right 比较后合并才能完成真正意义上的排序。

　　《?phpfunction gbSort($arr){ if(count($arr)《=1){return min="floor(count($arr)/2);//取中间数字进行拆分" left="gbSort($left);" right="gbSort($right);" return="" function=""》$right ? array_shift($right) : array_shift($left); //进行比较，小的移除，并且放入到数组$m中。 } return arr_merge($m,$left,$right);//进行合并（由于不知道left right 哪个会为空，所以进行统一合并）}?》

　　 六、堆排序

　　本例中fixDown函数实现对某一个节点的向下调整，这里默认的是起始节点为1，方便计算父子节点关系

　　注:

　　起始节点为1的父子关系: 父节点k, 子节点为2K、2k+1 子节点j, 父节点为 floor(j/2) floor为向下取整

　　起始节点为0的父子关系: 父节点k, 子节点为2K+1, 2k+2 子节点j, 父节点为 floor((j-1)/2)

　　参数$k为调整点位置, $lenth为数组长度，也就是从1起始到最后一个节点的坐标.

　　《?phpfunction fixDown(&$arr, $k, $lenth){while(2*$k《=$lenth) { //只要当前节点有子节点， 就需要继续该循环 $j = $k*2; if ($j《$lenth && $arr); fixDown($arr, 1, --$len); } array_shift($arr);}$arr = array(4,6,4,9,2,3);headSort($arr);?》

　　希望本文所述排序算法实例对大家的php程序设计有所帮助。

php几种排序算法实例详解

四种排序算法的PHP实现：
1) 插入排序(Insertion Sort)的基本思想是： 
每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子文件中的适当位置，直到全部记录插入完成为止。
2) 选择排序(Selection Sort)的基本思想是： 
每一趟从待排序的记录中选出关键字最小的记录，顺序放在已排好序的子文件的最后，直到全部记录排序完毕。
3) 冒泡排序的基本思想是： 
两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。
4) 快速排序实质上和冒泡排序一样，都是属于交换排序的一种应用。所以基本思想和上面的冒泡排序是一样的。
1. sort.php文件如下：
《?php
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;
      for($j = $i-1; $j 》= 0; $j--) { 
        if($arr 》 $tmp) {
          $arr;
          $arr = $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 = $j;
      }
      if ($min != $i) {
        $tmp = $arr;
        $arr;
        $arr = $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) {
          $tmp = $arr;
          $arr;
          $arr = $tmp;
        }
      }
    }
    return $arr;  
  }
  /**
   * 快速排序
   * @by www.5wx.org
   * @param  array
   * @return bool
   */
  private function quick_sort($arr) {
    //具体实现
    if (count($arr) 《= 1) return $arr; 
    $key = $arr;
    $left_arr = array();
    $right_arr = array();
    for ($i = 1; $i 《 count($arr); $i++){
      if ($arr 《= $key)
        $left_arr;
      else
        $right_arr;
    }
    $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 ’ . $msg . ’\n’;
    return @file_put_contents(’sort_err.log’, $msg, FILE_APPEND);
  }
}
/*End of file sort.php*/
/*Location htdocs/sort.php */
2. sort_demo.php文件如下：
《?php
require_once(’sort.php’);
$config = array (
  ’arr’ =》 array(23, 22, 41, 18, 20, 12, 200303,2200,1192) ,
  //需要排序的数组值
  ’sort’ =》 ’select’,
  //可能值: insert, select, bubble, quick
  ’debug’ =》 TRUE
  //可能值: TRUE, FALSE
);
$sort = new Sort($config);
//var_dump($config);
var_dump($sort-》display());
/*End of php*/

用php写出代码：3，6，7，1，8，2，9，4，5，0按照从小到大的顺序输出数组的值

这个问题，可以采用经典的冒泡排序。冒泡排序的过程如下：

1.比较相邻的元素。如果第一个比第二个大，就交换顺序。

2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。最后的元素会是最大的数。

3.针对所有的元素重复以上的步骤，除了最后一个。

4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

这个过程在转化成代码方式的思路为：

1. 每次从最开始的一对相邻元素比较，到结尾的一对元素比较完毕，可以看做一个完整的步骤，代码表示如下：

for ($j = 0;$j 《 count($arr)-1;$j++)// 每一次循环表示一次比较和交换的过程。

{

if ($arr)

{

$tmp = $arr;

$arr;

$arr = $tmp;

}

}

2.每次重新开始上一步骤都要比上一步少比较最后一个元素（因为上一步最后一个元素已经最大），这时需要增加一个外层循环来控制每次比较元素的个数。代码如下：

for($i = 0;$i 《 count($arr);$i++)// 每一次外层循环表示从头到尾执行了一次两两互相比较和交换。

{

for ($j = 0;$j 《 count($arr)-$i-1;$j ++)// 每一次内层循环表示一次比较和交换的过程。

{

if ($arr)

{

$tmp = $arr;

$arr;

$arr = $tmp;

}

}

}

完成过程代码如下：