排序算法(冒泡、快速、选择、插入)

  1.     header("content-type:text/html;charset=utf-8");  
  2.     array(2,5,9,4,7,6,1,8,3);
  3.     echo implode(" ",$arr)."
    "
    ;  
  4.     //---------------------------------------  
  5.     //       常用排序算法  
  6.     //---------------------------------------  
  7.     //冒泡    
  8.     function BubbleSort($arr)    
  9.     {      
  10.       $len=count($arr);    
  11.       //设置一个空数组 用来接收冒出来的泡    
  12.       //该层循环控制 需要冒泡的轮数    
  13.       for($i=1;$i<$len;$i++)    
  14.       { //该层循环用来控制每轮 冒出一个数 需要比较的次数    
  15.         for($k=0;$k<$len-$i;$k++)    
  16.         {    
  17.            if($arr[$k]>$arr[$k+1])    
  18.             {    
  19.                 $tmp=$arr[$k+1];    
  20.                 $arr[$k+1]=$arr[$k];    
  21.                 $arr[$k]=$tmp;    
  22.             }    
  23.         }    
  24.       }    
  25.       return $arr;    
  26.     }     
  27.     echo '冒泡排序:';  
  28.     echo implode(' ',BubbleSort($arr))."
    "
    ;  
  29.        
  30.     //快速排序  
  31.     function QSort($arr) {    
  32.         //先判断是否需要继续进行    
  33.         $length = count($arr);    
  34.         if($length <= 1) {    
  35.             return $arr;    
  36.         }    
  37.         //如果没有返回,说明数组内的元素个数 多余1个,需要排序    
  38.         //选择一个标尺    
  39.         //选择第一个元素    
  40.         $base_num = $arr[0];    
  41.         //遍历 除了标尺外的所有元素,按照大小关系放入两个数组内    
  42.         //初始化两个数组    
  43.         $left_array = array();//小于标尺的    
  44.         $right_array = array();//大于标尺的    
  45.         for($i=1; $i<$length$i++) {    
  46.             if($base_num > $arr[$i]) {    
  47.                 //放入左边数组    
  48.                 $left_array[] = $arr[$i];    
  49.             } else {    
  50.                 //放入右边    
  51.                 $right_array[] = $arr[$i];    
  52.             }    
  53.         }    
  54.         //再分别对 左边 和 右边的数组进行相同的排序处理方式    
  55.         //递归调用这个函数,并记录结果    
  56.         $left_array = QSort($left_array);    
  57.         $right_array = QSort($right_array);    
  58.         //合并左边 标尺 右边    
  59.         return array_merge($left_arrayarray($base_num), $right_array);    
  60.     }    
  61.     echo "快速排序:";  
  62.     echo implode(' ',QSort($arr))."
    "
    ;  
  63.        
  64.     //选择排序  
  65.     function SelectSort($arr) {    
  66.     //实现思路 双重循环完成,外层控制轮数,当前的最小值。内层 控制的比较次数    
  67.         //$i 当前最小值的位置, 需要参与比较的元素    
  68.         for($i=0, $len=count($arr); $i<$len-1; $i++) {    
  69.             //先假设最小的值的位置    
  70.             $p = $i;    
  71.             //$j 当前都需要和哪些元素比较,$i 后边的。    
  72.             for($j=$i+1; $j<$len$j++) {    
  73.                 //$arr[$p] 是 当前已知的最小值    
  74.                 if($arr[$p] > $arr[$j]) {    
  75.          //比较,发现更小的,记录下最小值的位置;并且在下次比较时,    
  76.      // 应该采用已知的最小值进行比较。    
  77.                     $p = $j;    
  78.                 }    
  79.             }    
  80.             //已经确定了当前的最小值的位置,保存到$p中。    
  81.      //如果发现 最小值的位置与当前假设的位置$i不同,则位置互换即可    
  82.             if($p != $i) {    
  83.                 $tmp = $arr[$p];    
  84.                 $arr[$p] = $arr[$i];    
  85.                 $arr[$i] = $tmp;    
  86.             }    
  87.         }    
  88.         //返回最终结果    
  89.         return $arr;    
  90.     }    
  91.     echo "选择排序:";  
  92.     echo implode(' ',SelectSort($arr))."
    "
    ;  
  93.        
  94.     //插入排序  
  95.     function InsertSort($arr) {    
  96.         //区分 哪部分是已经排序好的    
  97.         //哪部分是没有排序的    
  98.         //找到其中一个需要排序的元素    
  99.         //这个元素 就是从第二个元素开始,到最后一个元素都是这个需要排序的元素    
  100.         //利用循环就可以标志出来    
  101.         //i循环控制 每次需要插入的元素,一旦需要插入的元素控制好了,    
  102.         //间接已经将数组分成了2部分,下标小于当前的(左边的),是排序好的序列    
  103.         for($i=1, $len=count($arr); $i<$len$i++) {    
  104.             //获得当前需要比较的元素值。    
  105.             $tmp = $arr[$i];    
  106.             //内层循环控制 比较 并 插入    
  107.             for($j=$i-1;$j>=0;$j--) {    
  108.        //$arr[$i];//需要插入的元素; $arr[$j];//需要比较的元素    
  109.                 if($tmp < $arr[$j]) {    
  110.                     //发现插入的元素要小,交换位置    
  111.                     //将后边的元素与前面的元素互换    
  112.                     $arr[$j+1] = $arr[$j];    
  113.                     //将前面的数设置为 当前需要交换的数    
  114.                     $arr[$j] = $tmp;    
  115.                 } else {    
  116.                     //如果碰到不需要移动的元素    
  117.                //由于是已经排序好是数组,则前面的就不需要再次比较了。    
  118.                     break;    
  119.                 }    
  120.             }    
  121.         }    
  122.         //将这个元素 插入到已经排序好的序列内。    
  123.         //返回    
  124.         return $arr;    
  125.     }    
  126.     //var_dump(InsertSort($arr));  
  127.     echo '插入排序:';  
  128.     echo implode(' ',InsertSort($arr))."
    "
    ;  
    
    
  

     
 

你可能感兴趣的:(排序算法(冒泡、快速、选择、插入))