PHP基础算法

<?php
/*一、冒泡排序

基本思想：

对需要排序的数组从后往前（逆序）进行多遍的扫描，当发现相邻的两个数值的次序与排序要求的规则不一致时，就将这两个数值进行交换。这样比较小（大）的数值就将逐渐从后面向前面移动。
*/
function mysort($arr)
{
    for($i = 0; $i < count($arr); $i++)
    {
        $isSort = false;
        for ($j=0; $j< count($arr) - $i - 1; $j++)
        {
            if($arr[$j] < $arr[$j+1])
            {
                $isSort = true;
                $temp = $arr[$j];
                $arr[$j] = $arr[$j+1];
                $arr[$j+1] = $temp ;
            }
        }
        if($isSort)
        {
            break;
        }
    }
    return $arr;
}

$arr = array(3,1,2);
var_dump(mysort($arr));

/*二、快速排序

基本思想：

在数组中挑出一个元素（多为第一个）作为标尺，扫描一遍数组将比标尺小的元素排在标尺之前，将所有比标尺大的元素排在标尺之后，通过递归将各子序列分别划分为更小的序列直到所有的序列顺序一致。*/

//快速排序
function quick_sort($arr)
{
    //先判断是否需要继续进行
    $length = count($arr);
    if($length <= 1)
    {
        return $arr;
    }

    $base_num = $arr[0];//选择一个标尺 选择第一个元素

    //初始化两个数组
    $left_array = array();//小于标尺的
    $right_array = array();//大于标尺的
    for($i=1; $i<$length; $i++)
    {      //遍历 除了标尺外的所有元素，按照大小关系放入两个数组内
        if($base_num > $arr[$i])
        {
            //放入左边数组
            $left_array[] = $arr[$i];
        }
        else
        {
            //放入右边
            $right_array[] = $arr[$i];
        }
    }
    //再分别对 左边 和 右边的数组进行相同的排序处理方式
    //递归调用这个函数,并记录结果
    $left_array = quick_sort($left_array);
    $right_array = quick_sort($right_array);
    //合并左边 标尺 右边
    return array_merge($left_array, array($base_num), $right_array);
}

$arr = array(3,1,2);
var_dump(quick_sort($arr));

//快速排序第二种方法
//快速排序
function partition(&$arr,$low,$high){
    $pivotkey = $arr[$low];
    while($low<$high){
        while($low < $high && $arr[$high] >= $pivotkey){
            $high--;
        }
        $temp = $arr[$low];
        $arr[$low] = $arr[$high];
        $arr[$high] = $temp;
        while($low < $high && $arr[$low] <= $pivotkey){
            $low++;
        }
        $temp=$arr[$low];
        $arr[$low]=$arr[$high];
        $arr[$high]=$temp;
    }
    return$low;
}


function quick_sort2(&$arr,$low,$high){
    if($low < $high){
        $pivot = partition($arr,$low,$high);
        quick_sort2($arr,$low,$pivot-1);
        quick_sort2($arr,$pivot+1,$high);
    }
}
$arr = array(3,1,2);
var_dump(quick_sort2($arr,0,2));
//该算法是通过分治递归来实现的，其效率很大程度上取决于参考元素的选择，可以选择数组的中间元素，也可以随机得到三个元素，然后选择中间的那个元素（三数中值法）。另外还有一点，就是当我们在分割时，如果分割出来的子序列的长度很小的话（小于5到20），通常递归的排序的效率就没有诸如插入排序或希尔排序那么快了。因此可以会去判断数组的长度，如果小于10的话，直接用插入排序，而不再递归调用这个快速排序。

/*
 * 三、二分查找

基本思想：

假设数据是按升序排序的，对于给定值x，从序列的中间位置开始比较，如果当前位置值等于x，则查找成功；若x小于当前位置值，则在数列的前半段中查找；若x大于当前位置值则在数列的后半段中继续查找，直到找到为止。（数据量大的时候使用）
 */
//二分查找
function bin_search($arr,$low,$high,$k)
{
    if($low <= $high)
    {
        $mid = intval(($low + $high)/2);
        if($arr[$mid] == $k)
        {
            return $mid;
        }
        else if($k < $arr[$mid])
        {
            return bin_search($arr,$low,$mid-1,$k);
        }
        else
        {
            return bin_search($arr,$mid+1,$high,$k);
        }
    }
    return -1;
}

$arr = array(1,2,3,4,5,6,7,8,9,10);

print(bin_search($arr,0,9,3));

/*
 * 四、顺序查找

基本思想：

从数组的第一个元素开始一个一个向下查找，如果有和目标一致的元素，查找成功；如果到最后一个元素仍没有目标元素，则查找失败。
 */

//顺序查找
function seq_search($arr,$n,$k)
{
    $array[$n] = $k;
    for($i = 0;$i < $n; $i++)
    {
        if($arr[$i] == $k)
        {
            break;
        }
    }

    if($i < $n)
    {
        return $i;
    }
    else
    {
        return -1;
    }
}

/*
 * 洗牌算法
 */
$card_num = 54;//牌数
function wash_card($card_num){
    $cards = $tmp = array();
    for($i = 0;$i < $card_num;$i++){
        $tmp[$i] = $i;
    }

    for($i = 0;$i < $card_num;$i++){
        $index = rand(0,$card_num-$i-1);
        $cards[$i] = $tmp[$index];
        unset($tmp[$index]);
        $tmp = array_values($tmp);
    }
    return $cards;
}
// 测试：
print_r(wash_card($card_num));

/*
 * 二维数组排序算法函数，能够具有通用性，可以调用php内置函数。
 */
//二维数组排序，$arr是数据，$keys是排序的健值，$order是排序规则，1是降序，0是升序
function array_sort($arr,$keys,$order=0){
    if(!is_array($arr)){
        return false;
    }
    $keysvalue=array();
    foreach($arr as $key => $val){
        $keysvalue[$key] = $val[$keys];
    }
    if($order == 0){
        asort($keysvalue);
    }else{
        arsort($keysvalue);
    }
    reset($keysvalue);
    foreach($keysvalue as $key => $vals){
        $keysort[$key] = $key;
    }
    $new_array=array();
    foreach($keysort as $key=> $val){
        $new_array[$key]=$arr[$val];
    }
    return$new_array;
}
//测试
$person=array(
    array('id'=>2,'name'=>'zhangsan','age'=>23),
    array('id'=>5,'name'=>'lisi','age'=>28),
    array('id'=>3,'name'=>'apple','age'=>17)
);
$result = array_sort($person,'name',1);
print_r($result);

/*
 * 关于猴子的面试题
 * 一群猴子排成一圈，按1，2，...，n依次编号。然后从第1只开始数，数到第m只,把它踢出圈，从它后面再开始数，再数到第m只，在把它踢出去...，
 如此不停的进行下去，直到最后只剩下一只猴子为止，那只猴子就叫做大王。要求编程模拟此过程，输入m、n,输出最后那个大王的编号。（新浪）（小米）
 */
// 方案一，使用php来模拟这个过程
function king($n,$m){
    $mokey = range(1, $n);
    $i = 0;

    while (count($mokey) >1) {
        $i += 1;
        $head = array_shift($mokey);//一个个出列最前面的猴子
        if ($i % $m !=0) {
            #如果不是m的倍数，则把猴子返回尾部，否则就抛掉，也就是出列
            array_push($mokey,$head);
        }

        // 剩下的最后一个就是大王了
        return $mokey[0];
    }
}
// 测试
echo king(10,7);

// 方案二，使用数学方法解决
function josephus($n,$m){
    $r = 0;
    for ($i=2; $i <= $m ; $i++) {
        $r = ($r + $m) % $i;
    }

    return $r+1;
}
// 测试
print_r(josephus(10,7));

/*
 * 使对象可以像数组一样进行foreach循环，要求属性必须是私有。(Iterator模式的PHP5实现，写一类实现Iterator接口)（腾讯）
 */
class Test implements Iterator{
    private $item = array('id'=>1,'name'=>'php');

    public function rewind(){
        reset($this->item);
    }

    public function current(){
        return current($this->item);
    }

    public function key(){
        return key($this->item);
    }

    public function next(){
        return next($this->item);
    }

    public function valid(){
        return($this->current()!==false);
    }
}
//测试
$t=new Test;
foreach($t as $k=>$v){
    echo$k,'--->',$v,'<br/>';
}

/*
 * 用PHP实现一个双向队列（腾讯）
 */
class Deque{
    private $queue=array();
    public function addFirst($item){
        return array_unshift($this->queue,$item);
    }

    public function addLast($item){
        return array_push($this->queue,$item);
    }
    public function removeFirst(){
        return array_shift($this->queue);
    }

    public function removeLast(){
        return array_pop($this->queue);
    }
}



/*
 * 8.从0,1,2,3,4,5,6,7,8,9，这十个数字中任意选出三个不同的数字，“三个数字中不含0和5”的概率是（小米）
 */
function gailv(){
    $arr = array(0,1,2,3,4,5,6,7,8,9);
}

//9.一个三角形三个顶点有3只老鼠，一声枪响，3只老鼠开始沿三角形的边匀速运动，请问他们相遇的概率是（小米）
 function xiangyu(){
     /*
      * 75%，每只老鼠都有顺时针、逆时钟两种运动方向，3只老鼠共有8种运动情况，只有当3只老鼠都为顺时针或者逆时钟，它们才不会相遇，剩余的6中情况都会相遇，故相遇的概率为6/8=75%。
      */

 }

/*
 * 3、杨辉三角，用PHP写。

思路：每一行的第一位和最后一位是1，没有变化，中间是前排一位与左边一排的和，这种算法是用一个二维数组保存，另外有种算法用一维数组也可以实现，一行 一行的输出，有兴趣去写着玩下。

1
1   1
1   2   1
1   3   3   1
1   4   6   4   1
1   5  10  10   5   1
 */
//每行的第一个和最后一个都为1，写了6行
for($i=0; $i<6; $i++) {
    $a[$i][0]=1;
    $a[$i][$i]=1;
}
//出除了第一位和最后一位的值，保存在数组中
for($i=2; $i<6; $i++) {
    for($j=1; $j<$i; $j++) {
        $a[$i][$j] = $a[$i-1][$j-1]+$a[$i-1][$j];
    }
}
//打印
for($i=0; $i<6; $i++){
    for($j=0; $j<=$i; $j++) {
        echo $a[$i][$j].' ';
    }
    echo '<br/>';
}

/*
 * 4、在一组数中，要求插入一个数，按其原来顺序插入，维护原来排序方式。

思路：找到比要插入数大的那个位置，替换，然后把后面的数后移一位。
 */

$in = 2;
$arr = array(1,1,1,3,5,7);
$n = count($arr);
//如果要插入的数已经最大，直接打印
if($arr[$n-1] < $in) {
    $arr[$n+1] = $in; print_r($arr);
}
for($i=0; $i<$n; $i++) {
//找出要插入的位置
    if($arr[$i] >= $in){
        $t1= $arr[$i];
        $arr[$i] = $in;
//把后面的数据后移一位
        for($j=$i+1; $j<$n+1; $j++) {
            $t2 = $arr[$j];
            $arr[$j] = $t1;
            $t1 = $t2;
        }
//打印
        print_r($arr);
        die;
    }
}

/*
 * 8、牛年求牛：有一母牛，到4岁可生育，每年一头，所生均是一样的母牛，到15岁绝育，不再能生，20岁死亡，问n年后有多少头牛。（来自论坛）
 */
function t($n) {
    static $num = 1;
    for($j=1; $j<=$n; $j++){
        if($j>=4 && $j<15) {$num++;t($n-$j);}
        if($j==20){$num--;}
    }
     return $num;
}
//test
echo t(8);

/*
 * 插入排序   （insertion sort）— O(n2)
 * 【基本思想】：每次将一个待排序的数据元素，插入到前面已经排好序的数列中的适当位置，使数列依然有序；直到待排序数据元素 全部插入完为止。
 */
$data = array(6,13,21,99,18,2,25,33,19,84);
$nums = count($data)-1;
dump( $data );
InsertionSort($data,$nums);
dump( $data );
function InsertionSort(& $arr,$n )
{
    for( $i=1; $i<=$n; $i++ )
    {
        $tmp = $arr[$i];
        for( $j = $i; $j>0 && $arr[$j-1]>$tmp; $j-- )
        {
            $arr[$j] = $arr[$j-1];
        }
        $arr[$j] = $tmp;
    }
}
function dump( $d )
{
    echo '<pre>';print_r($d);echo '</pre>';
}

/*
 * 希 尔排序   （shell sort）— O(n log n)
 */
$data = array(6,13,21,99,18,2,25,33,19,84);
$nums = count($data);
dumps( $data );
ShellSort($data,$nums);
dumps( $data );
function ShellSort(& $arr,$n )
{
    for( $increment = intval($n/2); $increment > 0; $increment = intval($increment/2) )
    {
        for( $i=$increment; $i<$n; $i++ )
        {
            $tmp = $arr[$i];
            for( $j = $i; $j>= $increment; $j -= $increment )
                if( $tmp < $arr[ $j-$increment ] )
                    $arr[$j] = $arr[$j-$increment];
                else
                    break;
            $arr[$j] = $tmp;
        }
    }
}
function dumps( $d )
{
    echo '<pre>';print_r($d);echo '</pre>';
}

/**
 * 排列组合
 * 采用二进制方法进行组合的选择，如表示5选3时，只需有3位为1就可以了，所以可得到的组合是 01101 11100 00111 10011 01110等10种组合
 *
 * @param 需要排列的数组 $arr
 * @param 最小个数 $min_size
 * @return 满足条件的新数组组合
 */
function pl($arr,$size=5) {
    $len = count($arr);
    $max = pow(2,$len);
    $min = pow(2,$size)-1;
    $r_arr = array();
    for ($i=$min; $i<$max; $i++){
        $count = 0;
        $t_arr = array();
        for ($j=0; $j<$len; $j++){
            $a = pow(2, $j);
            $t = $i&$a;
            if($t == $a){
                $t_arr[] = $arr[$j];
                $count++;
            }
        }
        if($count == $size){
            $r_arr[] = $t_arr;
        }
    }
    return $r_arr;
}
$pl = pl(array(1,2,3,4,5,6,7),5);
var_dump($pl);
//递归算法
//阶乘
function f($n){
    if($n == 1 || $n == 0){
        return 1;
    }else{
        return $n*f($n-1);
    }
}
echo f(5);
//遍历目录
function iteral($path){
    $filearr = array();
    foreach (glob($path.'*') as $file){
        if(is_dir($file)){
            $filearr = array_merge($filearr,iteral($file));
        }else{
            $filearr[] = $file;
        }
    }
    return $filearr;
}
var_dump(iteral('d:www	est'));


/*
【选择排序（一维数组）】
【基 本思想】：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
【示例】：
[初 始关键字] [49 38 65 97 76 13 27 49]
第一趟排序后 13 ［38 65 97 76 49 27 49]
第 二趟排序后 13 27 ［65 97 76 49 38 49]
第三趟排序后 13 27 38 [97 76 49 65 49]
第 四趟排序后 13 27 38 49 [49 97 65 76]
第五趟排序后 13 27 38 49 49 [97 97 76]
第 六趟排序后 13 27 38 49 49 76 [76 97]
第七趟排序后 13 27 38 49 49 76 76 [ 97]
最 后排序结果 13 27 38 49 49 76 76 97
*/
function select_sort($arr){
    $count = count($arr);
    for($i=0; $i<$count; $i++){
        $k = $i;
        for($j=$i+1; $j<$count; $j++){
            if ($arr[$k] > $arr[$j])
                $k = $j;
        }
        if($k != $i){
            $tmp = $arr[$i];
            $arr[$i] = $arr[$k];
            $arr[$k] = $tmp;
        }
    }
    return $arr;
}
?>