常见算法

冒泡排序

思路分析：在要排序的一组数中，对当前还未排好的序列，从前往后对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即，每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。时间复杂度n^2 空间复杂度1

$arr=array(1,43,54,62,21,66,32,78,36,76,39);  
function bubbleSort($arr)
{  
  $len=count($arr);
  //该层循环控制 需要冒泡的轮数
  for($i=1;$i<$len;$i++)
  { //该层循环用来控制每轮 冒出一个数 需要比较的次数
    for($k=0;$k<$len-$i;$k++)
    {
       if($arr[$k]>$arr[$k+1])
        {
            $tmp=$arr[$k+1];
            $arr[$k+1]=$arr[$k];
            $arr[$k]=$tmp;
        }
    }
  }
  return $arr;
}

快速排序

思路分析：选择一个基准元素，通常选择第一个元素或者最后一个元素。通过一趟扫描，将待排序列分成两部分，一部分比基准元素小，一部分大于等于基准元素。此时基准元素在其排好序后的正确位置，然后再用同样的方法递归地排序划分的两部分。
时间复杂度nlogn 空间复杂度O(log2n)~O(n)

function quickSort($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);
}

二分法

<?php
  //二分查找
  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));
?>

关于猴子的面试题

<?php
    // 方案一，使用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));
?>

洗牌算法

<?php
    $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));
?>

有一母牛，到4岁可生育，每年一头，所生均是一样的母牛，到15岁绝育，不再能生，20岁死亡，问n年后有多少头牛

function cows ($n) {
    $cows = [1];
    for ($i = 1; $i <= $n; $i++) {
        // 新出生的牛
        $new_number = 0;
        foreach ($cows as $age => $num) {
            // 4岁到14岁的牛生育新的母牛
            if ($age >= 3 && $age <= 13) {
                $new_number += $num;
            }
        }
        // 将新出生的牛加到数组开头
        array_unshift($cows, $new_number);
        // 取出数组的前20个单元
        $cows = array_slice($cows, 0, 20);
    }
 
    return array_sum($cows);
}

斐波那契数列

 递归
function fbnq($n){
    if($n <= 0) return 0;
    if($n == 1 || $n == 2) return 1;
    return fbnq($n - 1) + fbnq($n - 2);
}
非递归
function fbnq($n){  //传入数列中数字的个数
    if($n <= 0){
        return 0;
    }
    $array[1] = $array[2] = 1; //设第一个值和第二个值为1
    for($i=3;$i<=$n;$i++){ //从第三个值开始
        $array[$i] = $array[$i-1] + $array[$i-2]; 
        //后面的值都是当前值的前一个值加上前两个值的和
    }
    return $array;
}

遍历一个文件下的所有文件和子文件夹下的文件

function all_file ($dir) {
    if (is_dir($dir)) {
        $resource = opendir($dir);
        while ($file = readdir($resource)) {
            if (in_array($file, ['.', '..'])) {
                continue;
            }elseif (is_dir($dir . '/' . $file)) {
                all_file($dir . '/' . $file);
            }else {
                echo $dir . '/' . $file, "\n";
            }
        }
    }else {
        echo $dir, "\n";
    }
}

遍历二叉树

class Node
{
    public $value;
    public $left;
    public $right;
}
 
/**
 * 先序遍历 根节点 ---> 左子树 ---> 右子树
 *
 * @param $root
 */
function preorder ($root) {
    echo $root->value;
    if (!empty($root->left)) {
        preorder($root->left);
    }
    if (!empty($root->right)) {
        preorder($root->right);
    }
}
 
/**
 * 中序遍历，左子树---> 根节点 ---> 右子树
 *
 * @param $root
 */
function inorder ($root) {
    if (!empty($root->left)) {
        inorder($root->left);
    }
    echo $root->value;
    if (!empty($root->right)) {
        inorder($root->right);
    }
}
 
/**
 * 后序遍历，左子树 ---> 右子树 ---> 根节点
 *
 * @param $root
 */
function tailorder ($root) {
    if (!empty($root->left)) {
        tailorder($root->left);
    }
    if (!empty($root->right)) {
        tailorder($root->right);
    }
    echo $root->value;
}
 
$d = new Node;
$d->value = 'D';
$b = new Node;
$b->value = 'B';
$b->left = $d;
$e = new Node;
$e->value = 'E';
$f = new Node;
$f->value = 'F';
$c = new Node;
$c->value = 'C';
$c->left = $e;
$c->right = $f;
$a = new Node;
$a->value = 'A';
$a->left = $b;
$a->right = $c;
 
preorder($a);echo "\n";
inorder($a);echo "\n";
tailorder($a);echo "\n";