二分查找，冒泡排序, 快速排序

<?php
class Test {
    /**
     * 二分查找 -- 要求：数组必须为已排好序的
     * 思路：无限切割即可，注意终止条件
     * @param $x int   想要查找的数字
     * @param $arr array  已排好序的数组
     * @param int $start int 开始查找位置索引
     * @param int|null $end end  结束查找位置索引
     * @return int|null int<索引值。从0开始> null<代表查无此数>
     */
    public function binarySearch($x, $arr, $start = 0, $end = null) {
        $count = count($arr);
        if ($end === null) {
            $end = $count - 1;
        }

        if ($start + 1 >= $end) {
            if (($arr[$end] !== $x)) {
                return null;
            } else {
                return $arr[$end];
            }
        }
        $mid = $start + intval(($end - $start)/ 2);
        if ($arr[$mid] === $x) {
            return $mid;
        } elseif ($arr[$mid] > $x) {
            return $this->binarySearch($x, $arr, 0, $mid);
        } elseif ($arr[$mid < $x]) {
            return $this->binarySearch($x, $arr, $mid, $end);
        }
    }

    /**
     * 冒泡排序
     * 思路：
     * * 如原始有X个值需要排序
     * * 控制最大的值一直往右移动，第一次循环必然造成最大的值会在最右侧
     * * 重复以上过程，冒泡 X-1, X-2, X-3...之间的值
     * @param $arr array 需排序的数组
     * @return array 排序结果
     */
    public function bubbleSort($arr) {
        $lastIndexer = count($arr) - 1;     //  最大的索引
        for ($i = 0; $i < $lastIndexer; $i++) {
            for ($j = 0; $j < $lastIndexer - $i; $j++) {
                if ($arr[$j] > $arr[$j + 1]) {
                    $temp = $arr[$j];
                    $arr[$j] = $arr[$j + 1];
                    $arr[$j + 1] = $temp;
                }
            }
        }
        return $arr;
    }

    /**
     * 冒泡排序2
     * 实现思路2，递归
     * @param $arr array 需排序的数组
     * $param $lastIndexer int|null 需检测的最大索引
     * @return array 排序结果
     */
    public function bubbleSort2($arr, $lastIndexer = null) {
        if ($lastIndexer === null) {
            $lastIndexer = count($arr) - 1;
        }
        if ($lastIndexer === 0) {
            return $arr;
        }
        for($i = 0; $i < $lastIndexer; $i++) {
            if ($arr[$i] > $arr[$i + 1]) {
                $tem = $arr[$i + 1];
                $arr[$i + 1] = $arr[$i];
                $arr[$i] = $tem;
            }
        }
        return $this->bubbleSort2($arr, $lastIndexer - 1);
    }

    /**
     * 快速排序
     * @param $arr
     */
    public function quickSort($arr) {
        if (count($arr) > 1) {
            $mid = array_pop($arr);
            $min = [];  //  更小的数据集合
            $max = [];  //  更大的数据集合
            foreach ($arr as $k => $v) {
                if ($v < $mid) {
                    $min[] = $v;
                } else {
                    $max[] = $v;
                }
            }
            // 分别对更小的以及更大的数进行快速排序
            $min = $this->quickSort($min);
            $max = $this->quickSort($max);
            return array_merge($min, [$mid], $max);
        } else {
            return $arr;
        }
    }
}
$test = new Test();
// 二分查找
$arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
$x = 10;
$index = $test->binarySearch($x, $arr);
var_dump($index);

// 冒泡排序
$arr2 = [2, 3, 1, 6, 9, 8, 0, 5, 4, 7];
$bubbleResult = $test->bubbleSort($arr2);
print_r($bubbleResult);
$bubbleResult2 = $test->bubbleSort2($arr2);
print_r($bubbleResult2);

// 快速排序
$quickSort = $test->quickSort($arr2);
print_r($quickSort);