PHP 查找随即数组中的最小的k个数

<?php
    #查找数组中最小的k个数
    
    function swap(&$arr, $i, $j) {
        $temp = $arr[$i];
        $arr[$i] = $arr[$j];
        $arr[$j] = $temp;
    }

    #第一种方法，使用选择排序直到排好序的部分元素个数为k，效率为O(kn)
    function select_sort_k($arr, $k) {
        if ($k >= count($arr)) {
            return $arr;
        }
        for ($i = 0; $i < count($arr); $i++) {
            $min = $i;
            for ($j = $i; $j < count($arr); $j++) {
                if ($arr[$j] < $arr[$min]) {
                    $min = $j;
                }
            }

            swap($arr, $i, $min);

            if ($i == $k - 1) {
                return array_slice($arr, 0, $k);
            }
        }
    }

    #第二种方法，通过建立最小堆，然后弹出最小元素来实现，效率为O(klogn)

    #调整堆节点
    #@param a 待调整数组
    #@param start 待调整部分开始坐标
    #@param len 待调整数组的长度
    function min_heapify(&$a, $start, $len) {
        $min = $start;
        $left = ($start + 1) * 2 - 1; #左孩子坐标
        $right = $left + 1; #右孩子坐标

        if ($left < $len) {
            if ($a[$min] > $a[$left]) {
                $min = $left;
            }
        }

        if ($right < $len) {
            if ($a[$min] > $a[$right]) {
                $min = $right;
            }
        }

        #递归调整节点
        if ($min != $start) {
            swap($a, $min, $start);
            min_heapify($a, $min, $len);
        }
    }

    #建立最小堆
    function build_min_heap(&$a) {
        #从最后一个非叶子节点开始调整堆
        for ($i = floor(count($a) / 2) - 1; $i >= 0; $i--) {
            min_heapify($a, $i, count($a));
        }
    }

    #利用类似于堆排序的过程查找最小的k个元素
    function heap_min_k(&$a, $k) {
        build_min_heap($a);
        for ($i = 0; $i < $k; $i++) {
            #交换首尾元素，并重新调整堆
            swap($a, 0, count($a) - 1);
            $r[] = array_pop($a);
            min_heapify($a, 0, count($a));
        }
        return $r;
    }

    #第三种方法，利用快排的partition来查找
    function rand_partition(&$a, $start, $end) {
        swap($a, $start, rand($start, $end));
        return partition($a, $start, $end);
    }

    function partition(&$a, $start, $end) {
        $pivot = $start;
        $low = $start + 1;
        $high = $end;
        while ($low < $high) {
            while ($low < $high && $a[$low] <= $a[$pivot]) {
                $low++;
            }

            #这里表示把所有与pivot相等的元素放到左边
            while ($low < $high && $a[$high] > $a[$pivot]) {
                $high--;
            }

            swap($a, $low, $high);
        }

        $change = $low;
        if ($a[$pivot] < $a[$change]) {
            $change--;
        }
        swap($a, $change, $pivot);
        return $change;
    }

    #利用类似于快排的性质来查找k个最小的元素
    function qsort_k(&$a, $start, $end, &$result, $k) {
        $q = rand_partition($a, $start, $end);
        $n = $q - $start + 1; #n表示包括q，小于等于q的元素的总数

        if ($n == $k) { #如果n = k，说明左边的元素正好足够，全部加入结果集
            array_splice($result, count($result), 0, array_slice($a, $start, $n));
        } else if ($n < $k) { #如果n < k, 说明左边的元素不够k个，将左边的元素和q一起归入结果集,并进入递归
            array_splice($result, count($result), 0, array_slice($a, $start, $n));
            qsort_k($a, $q + 1, $end, $result, $k - $n);
        } else {
            #元素有多，进入左边继续递归
            qsort_k($a, $start, $q - 1, $result, $k);
        }
    }

    $a = array(5, 7, 3, 2, 4, 6, 9, 0, 1);
    print_r($a);
    echo "<br>";
    print_r(select_sort_k($a, 5));
    echo "<br>";
    echo "<br>";

    $a = array(5, 7, 3, 2, 4, 6, 9, 0, 1);
    print_r($a);
    echo "<br>";
    print_r(heap_min_k($a, 5));
    echo "<br>";
    echo "<br>";

    $a = array(5, 7, 3, 2, 4, 6, 9, 0, 1);
    print_r($a);
    echo "<br>";
    $r = array();
    qsort_k($a, 0, count($a) - 1, $r, 5);
    print_r($r);
?>

Array ( [0] => 5 [1] => 7 [2] => 3 [3] => 2 [4] => 4 [5] => 6 [6] => 9 [7] => 0 [8] => 1 ) 
Array ( [0] => 0 [1] => 1 [2] => 2 [3] => 3 [4] => 4 ) 

Array ( [0] => 5 [1] => 7 [2] => 3 [3] => 2 [4] => 4 [5] => 6 [6] => 9 [7] => 0 [8] => 1 ) 
Array ( [0] => 0 [1] => 1 [2] => 2 [3] => 3 [4] => 4 ) 

Array ( [0] => 5 [1] => 7 [2] => 3 [3] => 2 [4] => 4 [5] => 6 [6] => 9 [7] => 0 [8] => 1 ) 
Array ( [0] => 0 [1] => 1 [2] => 3 [3] => 2 [4] => 4 )