php数据结构算法示例

 

排序算法：插入排序、冒泡排序、快速排序、分治|合并算法排序、归并算法排序、选择排序、基数排序、

            堆排序、希尔排序、间接排序、计数排序、桶排序。

    查找算法：循序搜寻法、顺序查找、二分查找、插捕搜寻法。

    其它算法：斐波那契数列、线性表删除、汉落塔算法、阶乘算法、指定三角形边输出倒三角形。

    算法学习：根据要求输出的长度，匹配预先定义好的字符中的字符组合各种可能进行输出、根据两个矩形的

            四个点的坐标求出交集四点坐标，还不够完善。

 

    个人未使用成功的用//Failure已做标记，要注意。如果您有解法，希望回贴答之，先表示感谢了。

 

 

<?php

//插入排序（数组排序）前提：、适合：元素个数较少的排序

//参数：insertion_sort(目标数组)

function insertion_sort($array) {

 

  $len   =count($array);

  if(0 >= $len) {

    return false;

  }

 

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

    $key   =$array[$j];

    $i   =$j-1;

    while($i>=0&& $array[$i]>$key){     //移值过程

    $array[$i+1]  = $array[$i];

    $i--;

    }

   

    $array[$i+1]  = $key;       //把最后要插入的值放到对应的位置

  }

 

  return $array;

}

//$array     = array("5","2", "4", "6", "1", "3");

//print_r(insertion_sort($array));

 

//冒泡排序（数组排序）

//参数：bubble_sort(目标数组)

function bubble_sort($array) {

 

  $len   =count($array);

  if(0 >= $len) {

    return false;

  }

 

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

    for ($j=$len-1;$j>$i; $j--) {     //方式一

//   for ($j=$i+1; $j<$len;$j++) {     //方式二

    if($array[$i]> $array[$j]) {   //从小到大排序

//   if($array[$i] <$array[$j]) {   //从大到小排序

      $temp  = $array[$j];

      $array[$j] = $array[$i];

      $array[$i] = $temp;

    }

    }

  }

 

  return $array;

}

//$array     = array("2","3", "1", "4");

//print_r(bubble_sort($array));

 

//快速排序（数组排序）

//参数说明quick_sort(数组)

function quick_sort($array) {

 

  $len   =count($array);

  if(1 >= $len) {

    return $array;

  }

 

  $key   = $array[0];

  $left_arr   = array();

  $right_arr   =array();

 

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

    if ($key >=$array[$i]) {

    $left_arr[]  = $array[$i];

    }else {

    $right_arr[] =$array[$i];

    }

  }

 

  $left_arr   =quick_sort($left_arr);

  $right_arr   =quick_sort($right_arr);

 

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

}

//$array     = array("2","4", "1", "3", "1");

//print_r(quick_sort($array));

 

//分治|合并算法排序（数组排序）前提：数组A[p...q]和A[q+1...r]已经排好序、适合：元素个数较多的排序

//参数：merge_sort(目标数组，开始位置，结束位置)

//Failure

//function merge_sort($array, $p, $q, $r) {

// 

// $n1   = $q - $p + 1;

// $n2   = $r - $q;

// for($i=1; $i<$n1; $i++) {

//   $arr1 = $array[$p+$i-1];

//   for ($j=1; $j<$n2; $j++){

//   $arr2   =$arr1[$q+$j];

//   $i     = 1;

//   $j     = 1;

//   for($k=$p; $k<=$r; $k++){

//     if($arr1[$i]<= $arr2[$j]) {

//     $array[$k]  = $arr1[$i];

//     $i++;

//     }else {

//     $array[$k]  = $arr2[$j];

//     $j++;

//     }

//   }

//   }

// }

// 

// return $array;

//}

//Failure

//function merge_sort_chil($array, $p, $q, $r) {

// 

// $len1   = $q - $p +1;

// $len2   = $r - $q;

// for($t=0; $t<$len1; $t++) {

//   $arr1[$t] = $array[$p+$t];

// }

// for ($t=0; $t<$len2; $t++) {

//   $arr2[$t] = $array[$q+$t+1];

// }

// 

// $i=$j   = 0;

// $k     = $p;

// while($i<$len1&& $j<$len2) {

//   if($arr1[$i] <= $arr2[$j]){

//   $array[$k++]   =$arr1[$i++];

//   }else {

//   $array[$k++]   =$arr2[$j++];

//   }

// }

// 

// while($i<$len1) {

//   $array[$k++]     = $arr1[$i++];

// }

// while($j<$len2) {

//   $array[$k++]     = $arr2[$j++];

// }

//}

//

//function merge_sort($array, $p, $r) {

// 

// if($p < $r) {

//   $q   = ($p+$r)/2;

//   merge_sort($array,$p,$q);

//   merge_sort($array,$q+1,$r);

//   merge_sort_chil($array,$p,$q,$r); 

// }

// 

// return $array;

//}

//归并算法排序（数组排序）前提：数组A[p...q]和A[q+1...r]已经排好序、适合：元素个数较多的排序

//前提：数组$arr1和$arr2已经排好序

function merge_sort($arr1, $arr2) {

 

  $len1   =count($arr1);

  $len2   =count($arr2);

  //$array[]   = $len1 +$len2;

  $i=$j=$k   = 0;

  while($i<$len1&& $j<$len2) {

    if ($arr1[$i]<= $arr2[$j]) {

    $array[$k++]  = $arr1[$i++];

    }else {

    $array[$k++]  = $arr2[$j++];

    }

  }

 

  while ($i<$len1) {

    $array[$k++]    = $arr1[$i++];

  }

  while ($j<$len2) {

    $array[$k++]    = $arr2[$j++];

  }

 

  return $array;

}

//$array     = array("5","2", "4", "6", "1", "3");

//$arr1     = array("1", "2","4");

//$arr2     = array("3", "5","6");

//print_r(merge_sort($arr1, $arr2));

 

//选择排序（数组排序）前提：、适合：

//参数：select_sort(目标数组)

function select_sort($array) {

 

  $len   =count($array);

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

    $key   =$array[$i];

    $loc   =$i;

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

    if($array[$j]< $key) {

      $key  = $array[$j];

      $loc  = $j;

    }

    }

   

    $array[$loc]  = $array[$i];

    $array[$i]  = $key;

  }

 

  return $array;

}

//$array     = array("5","2", "4", "6", "1", "3");

//print_r(select_sort($array));

 

//基数排序（数组排序）前提：、适合：

//参数：base_sort(目标数组，基数值)

//Failure

//function base_sort($array, $key) {

// 

// $len   = count($array);

// $k     = 0;

// $n     = 1;

// while($n <= $key) {

//   for($i=0; $i<$len; $i++){

//   $lsd       = (($array[$i]/$n));

//   $temp[$lsd][$order[$lsd]] =$array[$i];

//   $order[$lsd]++;

//   }

//   for ($i=0; $i<$len; $i++){

//   if($order[$i] != 0) {

//     for ($j=0;$j<$order[$i]; $j++) {

//     $array[$k]  = $temp[$i][$j];

//     }

//     $order[$i]    = 0;

//   }

//   $n *= 10;

//   $k = 0;

//   }

// }

// 

// return $array;

//}

$array     = array("5", "2","4", "6", "1", "3");

//print_r(base_sort($array, 4));

 

//堆排序（数组排序）前提：、适合：

//参数：heap_sort(目标数组，长度)

//未理解

function heap_sort(&$array) {

 

  $last   =count($array);

  array_unshift($array, 0);

  $i     =$last>>1;

  while (true) {

    adjust_node($i, $last,$array);

    if ($i > 1){

    $i--;

    }else {

    if($last==1) {

      break;

    }

    swap($array[$last],$array[1]);

    $last--;

    }

  }

 

  array_shift($array); 

  return $array;

}

function adjust_node($n, $last, &$array){

  $l     =$n<<1;

  if(!isset($array[$l])||$l>$last) {

    return ;

  }

 

  $r     =$l+1;

  if($r<=$last&&$array[$r]>$array[$l]) {

    $l   =$r;

  }

  if($array[$l] > $array[$n]){

    swap($array[$l],$array[$n]);

    adjust_node($l, $last,$array);

  }

}

function swap(&$a, &$b){

 

  $a     = $a^ $b;

  $b     = $a^ $b;

  $a     = $a^ $b;

 

// $temp   = $a;

// $a     = $b;

// $b     = $temp;

}

//$array     = array("5","2", "4", "6", "1", "3");

//print_r(heap_sort($array));

 

//希尔排序（数组排序）前提：、适合：缩小增量排序，不稳定

//参数：shell_sort(目标数组)

//Failure

function shell_sort($array) {

 

  $len   =count($array);

  for ($inc=1; $inc<=$len/9;$inc=3*$inc+1);

  for (; $inc>0; $inc/=3){

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

    $t   =$array[$i-1];

    $j   =$i;

    while(($j>$inc) &&($array[$j-$inc-1])>$t) {

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

      $j    -= $inc;

    }

     

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

    }

  }

 

  return $array;

}

//希尔排序

//Failure

function shell_sort2($array, $from, $len) {

 

  $value   = 1;

  while(($value+1)*2 < $len){

    $value   =($value+1)*2 - 1;

  }

 

  for ($delta=$value;$delta>=1; $delta=($delta+1)/2-1) {

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

    modify_insert_sort($array, $from+$i, $len-$i, $delta);

    }

  }

 

  return $array;

}

function modify_insert_sort($array, $from, $len, $delta){

 

  if($len <= 1) {

    return ;

  }

 

  $temp   = null;

  for ($i=$from+$delta;$i<$from+$len; $i+=$delta) {

    $temp   =$array[$i];

    $j   =$i;

    for (;$j>$from; $j-=$delta) {

    if(strcmp($temp,$array[$j-$delta]) < 0) {

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

    }else {

      break;

    }

     

    $array[$j]    = $temp;

    }

  }

 

  //return $array;

}

//$array     = array("5","2", "4", "6", "1", "3");

//print_r(shell_sort2($array, 0, 6));

 

//间接排序（数组排序）前提：、适合：复制代价很高的元素。

//参数：indirect_sort(目标数组，数组长度)

//FaulureURL:http://www.cppblog.com/yuziyu/archive/2009/07/16/90212.html

function indirect_sort($array, $len) {

 

  if($array==NULL || $len<=0){

    return 0;

  }

 

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

    $index[$i]  = i;

  }

 

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

    $temp     = $index[$i];

    for($j=$i;$j-1>=0&&$array[$j-1]>$array[$temp];--$j) {

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

    }

    $index[$j]  = $temp;

  }

 

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

    if($index[$i] == $i){

    continue;

    }else {

    $temp   = $array[$i];

    $j     = $i;

    while($index[$j] != $i){

      $array[$j] = $array[$index[$j]];

      $temp2  = $j;

      $j  = $index[$j];

     

      $index[$temp2]   = $temp2;

    }

     

    $array[$j]    = $temp;

    $index[$j]    = $j;

    }

  }

 

  return 1;

}

//$array     = array("5","2", "4", "6", "1", "3");

//print_r(indirect_sort($array, 6));

 

//计数排序（数组排序）前提：、适合：计数排序的基本思想就是对每一个输入元素X，确定出小于X的元素个数后插入到对应位置

//参数：count_sort(目标数组)

function count_sort($array, $size) {

 

  $min=$max   =$array[0];

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

    if($array[$i]< $min) {

    $min   =$array[$i];

    }else if($array[$i]> $max) {

    $max   =$array[$i];

    }

  }

  $range     = $max - $min + 1;

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

    $count[$i]  = 0;

  }

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

    $count[$array[$i]-$min]++;

  }

 

  $z     =0;

  for($i=$min; $i<=$max; $i++){

    for($j=0;$j<$count[$i-$min]; $j++) {

    $array[$z++] = $i;

    }

  }

 

  return $array;

}

//$array     = array("5","2", "4", "6", "6", "1", "1", "3");

//print_r(count_sort($array, 8));

 

//基数排序（数组排序）前提：、适合：

//参数：distribution_sort(目标数组，数组长度)

//Failure URL:http://baike.baidu.com/view/1170573.htm

function distribution_sort($array, $d) {

 

  $len   =count($array);

  $n=$m   = 1;

  $k     =0;

  $temp=$order = array();

 

  while($m<=$d) {

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

    $lsd =(($array[$i]/$n));

    $temp[$lsd][$order[$lsd]]  = $array[$i];

    $order[$lsd]++;

    }

   

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

    if ($order[$i] != 0){

      for($j=0; $j<$order[$i]; $j++) {

      $array[$k]     =$temp[$i][$j];

      $k++;

      }

      $order[$i]     = 0;

    }

     

    $n   *=10;

    $k   =0;

    $m++;

    }

  }

 

  return $array;

}

//FailureURL:http://www.cnblogs.com/sun/archive/2008/06/26/1230095.html

function radix_sort($array, $digit) {

 

  $len   =count($array);

  for ($k=1; $k<=$digit; $k++){

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

    $tempSplitDigit  = $array[$i]/math_pow(10,$k-1) -($array[$i]/math_pow(10,k))*10;

    $tempcountsortarray[$tempSplitDigit]   += 1;   

    }

   

    for ($m=1;$m<10; $m++) {

    $tempcountsortarray[$m]      +=$tempcountsortarray[$m-1];

    }

   

    for ($n=$len-1;$n>=0; $n--) {

    $tempSplitDigit  = $array[$n]/math_pow(10,$k-1) -($array[$n]/math_pow(10,$k))*10;

    $tempArray[$tempcountsortarray[$tempSplitDigit]-1]  = $array[$n];

    $tempcountsortarray[$tempSplitDigit]     -= 1;

    }

   

    for ($p=0;$p<$len; $p++) {

    $array[$p]  = $tempArray[$p];

    }

  }

 

  return $array;

}

function math_pow($d, $n) {

 

  $value   = 1;

  if($n <= 0) {

    return 1;

  }else {

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

    $value = $value*$d;

    }

  }

 

  return $value;

}

//$array     = array("5","2", "4", "6", "1", "3");

//print_r(radix_sort($array, 3));

 

//桶排序（数组排序）前提：、适合：桶排序就是排序数字按大小划分为n段，每段装在一个桶里，然后对各个桶分别排序

//参数：bucket_sort(目标数组，开始排序位置，数组长度，数组最大值)

//Failure

function bucket_sort($keys, $from, $len, $max) {

 

  $temp=$count   =array();

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

    $count[$keys[$from+$i]]++;

  }

 

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

    $count[$i]  = $count[$i] + $count[$i-1];

  }

 

  array_copy($keys, $from, $temp, 0,$len);

  for ($k=$len-1; $k>=0; $k--){

    $keys[--$count[$temp[$k]]]  = $temp[$k];

  }

 

  return $keys;

 

}

function array_copy($keys, $from, &$temp,$start, $len) {

 

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

    $temp[$start++]  = $keys[$from++];

  }

}

//$array     = array("5","2", "4", "6", "1", "3");

//print_r(bucket_sort($array, 0, 6, 6));

 

 

 

//循序搜寻法（数组值查找）前提：、适合：

//参数：(目标数组，键值)

function liner_search($array, $key) {

 

  $i     =0;

  while($array[$i] != $key) {

    $i++;

  }

 

  return $i;

}

//$array     = array("5","2", "4", "6", "1", "3");

//print_r(liner_search($array, 1));

//顺序查找（数组里的某个元素）

//参数：sequence_search(目标数组，查找范围，目标值)

function sequence_search($array, $n, $k) {

 

// $array[$n]   = $k;

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

    if($array[$i] == $k){

    break;

    }

  }

 

  if ($i < $n) {

    return $i;

  }else {

    return -1;

  }

}

//$array     = array("1","2", "3", "4");

//echo sequence_search($array, 4, 3);

 

//二分查找（数组里查找某个元素），前提：该数组已经按从小到大的顺序排列好了

//参数：bin_sch(目标数组，开始位置，最终位置，目标值)

function bin_sch($array, $low, $high, $k) {

 

  if($low <= $high) {

    $mid     = intval(($low+$high)/2);

    if($array[$mid] == $k){

    return $mid;

    }elseif ($k< $array[$mid]) {

    return bin_sch($array,$low, $mid-1, $k);

    }else {

    return bin_sch($array,$mid+1, $high, $k);

    }

  }

 

  return -1;

}

//$array     = array("1","2", "3", "4");

//echo bin_sch($array, 2, 3, 4);

 

//插捕搜寻法（数组查找元素）前提：、适合：分布平均的数组

//参数：interpolation_sch(目标数组，目标值)

//Failure

function interpolation_sch($array, $key) {

 

  $low   = 0;

  $upper   = count($array)-1;

  while($low <= $upper) {

    $mid   =($upper-$low) * ($key-$array[$low])/($array[$upper]-$array[$low]) +$low;

    if($mid<$low ||$mid>$upper) {

    return -1;

    }

    if ($key <$array[$mid]) {

    $upper = $mid -1;

    }elseif ($key> $array[$mid]) {

    $low = $mid + 1;

    }else {

    return $mid;

    }

  }

 

  return -1;

}

//$array     = array("5","2", "4", "6", "1", "3");

//print_r(interpolation_sch($array, 2));

 

 

//斐波那契数列（计算总和）前提：、适合：

//参数：fibonacci(长度)

function fibonacci($n) {

 

  if(0==$n || 1==$n) {

    return $n;

  }

 

  $array[0]   = 0;

  $array[1]   = 1;

  $totle     = 1;

  for($i=2; $i<=$n; $i++){

    $array[$i]  = $array[$i-1] + $array[$i-2];

    $totle   += $array[$i];

  }

 

  $result["sort"]   =$array;

  $result["totle"] = $totle;

   

  return $result;

}

//print_r(fibonacci(5));

 

//线性表删除（数组中实现）

//参数：delete_array_element(目标数组，删除位置)

function delete_array_element($array, $i) {

 

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

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

  }

  array_pop($array);

  return $array;

}

//$array     = array("1","2", "3", "4");

//print_r(delete_array_element($array, 2));

 

//汉落塔算法，前提：、适合：

//hanoi参数：(塔高数，柱1，柱2，柱3)

function hanoi($key, $a, $b, $c) {

 

    if(1 == $key) {

    echo "Move sheet {$key}from {$a} to {$c}" . "<br />";

    }else {

    hanoi($key-1, $a, $c,$b);

    echo "Move sheet {$key}from {$a} to {$c}" . "<br />";

    hanoi($key-1, $b, $a,$c);

    }

}

//print_r(hanoi(3, "A", "B", "C" ));

 

//阶乘算法

//factorial参数：(阶乘基数)

function factorial($value) {

 

  if(0 >= ceil($value)) {

    return 0;

  }else {

   

    $sum   =1;

    while($value>1) {

    $sum = $sum *$value;

    $value--;

    }

   

    return $sum;

  }

}

//$fact_value   = factorial(5);

//print_r($fact_value);

 

//指定三角形边输出倒三角形

//reverse_triangle参数：(三角形边长)

function reverse_triangle($len) {

 

  if(0 >= ceil($len)) {

    return 'invalidvalue';

  }else {

   

    $width   =$len;

    $triangle = "";

   

    while($width>=0) {

     

    $blank =($len-$width);

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

      $triangle   .="&nbsp;";

    }

     

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

      $triangle   .="*&nbsp;"; 

    }

     

    $triangle  .= "<br />";

    $width--;

    }

   

    return $triangle;

  }

}

function reverse_triangle2($len) {

 

  if(0 >= ceil($len)) {

    return 'invalidvalue';

  }else 

  {

    $a   =0;

    $triangle = "";

    for ($i=$len;$i>0; $i--) {

    $a++;

    $j   =$i*2 - 1;

    for ($k=0;$k<$j; $k++) {

      $triangle   .= "*";

    }

    $triangle  .= "<br />";

     

    for($x=$a;$x>0; $x--) {

      $triangle   .="&nbsp;";

    }

    }

   

    return $triangle;

  }

}

//$triangle   = reverse_triangle(6);

//$triangle2   = reverse_triangle2(6);

//print_r($triangle);

//print_r($triangle2);

 

 

 

//根据要求输出的长度，匹配预先定义好的字符中的字符组合各种可能进行输出

function gene_dic($n){

//$source='0123456789abcdefghijklmn opqrstuvwxyz';

$source='0123456789';

$len=strlen($source);

$count=1;

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

    $count*=$len;

    $series[]=0;}

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

    $word='';

    $tonext_value=1;//小循环前设好给末位进位

    for($no=$n-1;$no>=0;$no--){ 

      $word=$source{$series[$no]}.$word;

      $series[$no]+=$tonext_value;

      if($no>0){

        if($series[$no]==$len){

            $series[$no]=0;

          $tonext_value=1;

          }else{

          $tonext_value=0;

          } } }

echo "$word ";

}

}

//gene_dic(2);

 

//根据两个矩形的四个点的坐标求出交集四点坐标，还不够完善

//矩形一的四点：a,b,c,d、矩形二四点：e,f,g,k

function rectangle_intersect($a, $b, $c, $d, $e, $f, $g, $h){

 

  if($e[0]>$b[0] ||$g[1]>$b[1]) {

    return "NoIntersect."; 

  }else if($e[0]==$b[0]) {

    $i=$j   =$b;

    $k=$l   =$d;

  }else if($g[1]==$b[1]) {

    $i=$k   =$g;

    $j=$l   =$d;

  }else if($e[0]<$b[0] ||$g[1]<$b[1]) {

    if(($e[1]-$g[1])> ($a[1]-$c[1])) {

    $i[0]=$k[0]  = $e[0];

    $i[1]=$j[1]  = $a[1];

    $j[0]=$l[0]  = $b[0];

    if($g[1] <$c[1]) {

      $k[1]=$l[1]   = $c[1];

    }else {

      $k[1]=$l[1]   = $g[1];   

    }

    }else {

    $i[0]=$k[0]  = $e[0];

    $i[1]=$j[1]  = $a[1];

    $j[0]=$l[0]  = $b[0];

    $k[1]=$l[1]  = $g[1];   

    }

  }

 

  return array($i, $j, $k, $l);

}

//以坐标的方式输出

//$res = rectangle_intersect(array(2,5), array(5,5),array(2,3), array(5,3), array(4,7), array(10,7), array(4,4),array(10,4)); //有交集

//$res = rectangle_intersect(array(-2,6), array(2,6),array(-2,4), array(2,4), array(-1,5), array(1,5), array(-1,-3),array(1,-3));

//print_r($res);

 

?>