经典排序算法的PHP实现类

近期广受笔试摧残，对于各种排序也是晕头转向。
更坑爹的是貌似大多都是用C++、Java实现相关算法，让我搞PHP的情何以堪，更何况，PHP本身就有排序函数sort()，其实来说，是很简单的，这也可能是为什么不用PHP进行排序吧。
但考虑到PHP毕竟也是一门面向对象的语言吧，我们利用原生的语法，也是可以实现经典排序算法的，先不说性能如何，切不要妄自菲薄吧。
下面为具体的经典排序算法的PHP实现类。

<?php

/**
 * Author: helen
 * CreateTime: 2016/4/15 23:12
 * description: PHP--排序函数（数组排序）
 */
class SORT
{
    //属性值：存储传入的数组
    protected $array = array();
    //属性值：数组长度
    protected $length;

    /*
     * SORT类初始化函数
     * @access public
     * @param array $array 传入的需要进行排序的函数
     * @return object $this 对象本身
     * */
    public function __construct(array $array)
    {
        $this->array = $array;
        $this->length = count($array);
        return $this;
    }

    /*
     * 冒泡排序
     * 算法思想：两两比较相邻元素（记录）的关键字，如果反序则交换，直到没有反序的元素（记录）为止
     * 复杂度：时间复杂度：o(n*n)
     * 辅助空间：o(1)
     * 稳定性：稳定
     * @access public
     * @param string $type 排列顺序：升序asc，降序desc;默认升序asc
     * @return array $array 排序完成的数组
     * @return string $exchange_count 排序过程中交换的次数
     * @return string $compare_count 排序过程中比较的次数
     * */
    public function BubbleSort($type = ‘asc‘)
    {
        $array = $this->array;
        $length = $this->length;
        $exchange_count = 0;      //交换次数
        $compare_count = 0;       //比较次数
        $flag = true;             //标记，目的在于减少比较次数
        switch ($type) {
            case ‘asc‘:     //升序排列
                for ($i = 0; $i < $length && $flag; $i++) {      //若flag为true则退出循环
                    $flag = false;
                    for ($j = $length - 2; $j > $i; $j--) {
                        if ($array[$j] > $array[$j + 1]) {
                            $tmp = $array[$j];
                            $array[$j] = $array[$j + 1];
                            $array[$j + 1] = $tmp;
                            $exchange_count++;
                            $flag = true;   //如果有数据交换，则flag为true
                        }
                        $compare_count++;
                    }
                }
                break;
            case ‘desc‘:    //降序排列
                for ($i = 0; $i < $length && $flag; $i++) {          //若flag为true则退出循环
                    $flag = false;
                    for ($j = $length - 2; $j >= $i; $j--) {
                        if ($array[$j] < $array[$j + 1]) {
                            $tmp = $array[$j];
                            $array[$j] = $array[$j + 1];
                            $array[$j + 1] = $tmp;
                            $exchange_count++;
                            $flag = true;   //如果有数据交换，则flag为true
                        }
                        $compare_count++;
                    }
                }
                break;
        }
        return array(
            ‘array‘ => $array,
            ‘exchange_count‘ => $exchange_count,
            ‘compare_count‘ => $compare_count
        );
    }

    /*
     * 简单选择排序
     * 算法思想：通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的元素（记录），并和第i（1=<i<=n）个元素（记录）交换之
     * 复杂度：o(n*n)
     * 辅助空间：o(1)
     * 稳定性：稳定
     * @access public
     * @param string $type 排列顺序：升序asc,降序desc;默认升序asc
     * @return array $array 排序完成的数组
     * @return string $exchange_count 排序过程中交换的次数
     * @return string $compare_count 排序过程中比较的次数
     * */
    public function SelectSort($type = ‘asc‘)
    {
        $array = $this->array;
        $length = $this->length;
        $exchange_count = 0;      //交换次数
        $compare_count = 0;       //比较次数
        switch ($type) {
            case ‘asc‘:
                for ($i = 0; $i < $length; $i++) {
                    $min = $i;          //将当前下标定义为最小值下标
                    for ($j = $i + 1; $j < $length; $j++) {   //循环之后的数据
                        if ($array[$min] > $array[$j]) {    //如果有小于当前最小值的关键字
                            $min = $j;                  //将此关键字的下标赋值给min
                        }
                        $compare_count++;
                    }
                    if ($i != $min) {       //若min不等于i，说明找到最小值，交换
                        $tmp = $array[$min];
                        $array[$min] = $array[$i];
                        $array[$i] = $tmp;
                        $exchange_count++;
                    }
                }
                break;
            case ‘desc‘:
                for ($i = 0; $i < $length; $i++) {
                    $max = $i;          //将当前下标定义为最大值下标
                    for ($j = $i + 1; $j < $length; $j++) {   //循环之后的数据
                        if ($array[$max] < $array[$j]) {    //如果有大于当前最da值的关键字
                            $max = $j;                  //将此关键字的下标赋值给max
                        }
                        $compare_count++;
                    }
                    if ($i != $max) {       //若min不等于i，说明找到最大值，交换
                        $tmp = $array[$max];
                        $array[$max] = $array[$i];
                        $array[$i] = $tmp;
                        $exchange_count++;
                    }
                }
                break;
        }
        return array(
            ‘array‘ => $array,
            ‘exchange_count‘ => $exchange_count,
            ‘compare_count‘ => $compare_count
        );
    }

    /*
     * 直接插入排序
     * 算法思想：将一个元素（记录）插入到已经排好序的有序表中，从而得到一个新的，元素（记录）数增1的有序表
     * 复杂度：o(n*n)
     * 辅助空间：o(1)
     * 稳定性：稳定
     * @access public
     * @param string $type 排列顺序：升序asc,降序desc;默认升序asc
     * @return array $array 排序完成的数组
     * @return string $exchange_count 排序过程中交换的次数
     * @return string $compare_count 排序过程中比较的次数
     * */
    public function InsertSort($type = ‘asc‘)
    {
        $array = $this->array;
        $length = $this->length;
        $exchange_count = 0;      //交换次数
        $compare_count = 0;       //比较次数
        switch ($type) {
            case ‘asc‘:
                for ($i = 1; $i < $length; $i++) {
                    if ($array[$i] < $array[$i - 1]) {    //须将$array[$i]插入有序子表
                        $flag = $array[$i];     //设置哨兵
                        for ($j = $i - 1; $array[$j] > $flag && $j >= 0; $j--) {
                            $array[$j + 1] = $array[$j];    //记录后移
                            $compare_count++;
                        }
                        $array[$j + 1] = $flag;   //插入到正确位置
                        $exchange_count++;
                    }
                }
                break;
            case ‘desc‘:
                for ($i = 1; $i < $length; $i++) {
                    if ($array[$i] > $array[$i - 1]) {    //须将$array[$i]插入有序子表
                        $flag = $array[$i];     //设置哨兵
                        for ($j = $i - 1; $array[$j] < $flag && $j >= 0; $j--) {
                            $array[$j + 1] = $array[$j];    //记录后移
                            $compare_count++;
                        }
                        $array[$j + 1] = $flag;   //插入到正确位置
                        $exchange_count++;
                    }
                }
                break;
        }
        return array(
            ‘array‘ => $array,
            ‘exchange_count‘ => $exchange_count,
            ‘compare_count‘ => $compare_count
        );
    }

    /*
     * 希尔排序
     * 算法思想：序列分割--基本有序，然后进行直接插入排序。将相距某个增量的元素(记录)组成一个子序列，保证在子序列中分别进行直接插入排序后得到的结果是基本有序(小的关键字基本在前面，大的关键字基本在后面)
     * 复杂度：o(n*logn)~o(n*n)
     * 辅助空间：o(1)
     * 稳定性：不稳定
     * @access public
     * @param string $type 排列顺序：升序asc,降序desc;默认升序asc
     * @return array $array 排序完成的数组
     * @return string $exchange_count 排序过程中交换的次数
     * @return string $compare_count 排序过程中比较的次数
     * */
    public function ShellSort($type = ‘asc‘)
    {
        $array = $this->array;
        $length = $this->length;
        $exchange_count = 0;      //交换次数
        $compare_count = 0;       //比较次数
        switch ($type) {
            case ‘asc‘:
                for ($gap = $length >> 1; $gap > 0; $gap >>= 1) {
                    for ($i = $gap; $i < $length; $i++) {
                        $temp = $array[$i];
                        for ($j = $i - $gap; $j >= 0 && $array[$j] > $temp; $j -= $gap) {
                            $array[$j + $gap] = $array[$j];
                            $compare_count++;
                        }
                        $array[$j + $gap] = $temp;
                        $exchange_count++;
                    }
                }
                break;
            case ‘desc‘:
                for ($gap = $length >> 1; $gap > 0; $gap >>= 1) {
                    for ($i = $gap; $i < $length; $i++) {
                        $temp = $array[$i];
                        for ($j = $i - $gap; $j >= 0 && $array[$j] < $temp; $j -= $gap) {
                            $array[$j + $gap] = $array[$j];
                            $compare_count++;
                        }
                        $array[$j + $gap] = $temp;
                        $exchange_count++;
                    }
                }
                break;
        }
        return array(
            ‘array‘ => $array,
            ‘exchange_count‘ => $exchange_count,
            ‘compare_count‘ => $compare_count
        );
    }

    /*
     * 堆排序
     * 算法思想：将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根节点。将它移走，然后将剩余元素重新构造成一个堆，再移走根节点，以此类推。
     * 复杂度：o(n*logn)
     * 辅助空间：o(1)
     * 稳定性：不稳定
     * @access public
     * @param string $type 排列顺序：升序asc,降序desc;默认升序asc
     * @return array $array 排序完成的数组
     * @return string $exchange_count 排序过程中交换的次数
     * @return string $compare_count 排序过程中比较的次数
     * */
    public function HeapSort($type = ‘asc‘)
    {
        $array = $this->array;
        $length = $this->length;
        $exchange_count = 0;      //交换次数
        $compare_count = 0;       //比较次数
        switch ($type) {
            case ‘asc‘:
                $array = self::heap_sort_asc($array);
                break;
            case ‘desc‘:
                $array = self::heap_sort_desc($array);
                break;
        }
        return array(
            ‘array‘ => $array,
            ‘exchange_count‘ => $exchange_count,
            ‘compare_count‘ => $compare_count
        );
    }

    protected function swap(&$x, &$y)
    {
        $t = $x;
        $x = $y;
        $y = $t;
    }

    protected function max_heapify_asc(&$arr, $start, $end)
    {
        //建立父節點指標和子節點指標
        $dad = $start;
        $son = $dad * 2 + 1;
        if ($son >= $end)//若子節點指標超過範圍直接跳出函數
            return;
        if ($son + 1 < $end && $arr[$son] < $arr[$son + 1])//先比較兩個子節點大小，選擇最大的
            $son++;
        if ($arr[$dad] <= $arr[$son]) {//如果父節點小於子節點時，交換父子內容再繼續子節點和孫節點比較
            self::swap($arr[$dad], $arr[$son]);
            self::max_heapify_asc($arr, $son, $end);
        }
    }

    protected function heap_sort_asc($arr)
    {
        $len = count($arr);
        //初始化，i從最後一個父節點開始調整
        for ($i = $len / 2 - 1; $i >= 0; $i--)
            self::max_heapify_asc($arr, $i, $len);
        //先將第一個元素和已排好元素前一位做交換，再從新調整，直到排序完畢
        for ($i = $len - 1; $i > 0; $i--) {
            self::swap($arr[0], $arr[$i]);
            self::max_heapify_asc($arr, 0, $i);
        }
        return $arr;
    }

    protected function max_heapify_desc(&$arr, $start, $end)
    {
        //建立父節點指標和子節點指標
        $dad = $start;
        $son = $dad * 2 + 1;
        if ($son >= $end)//若子節點指標超過範圍直接跳出函數
            return;
        if ($son + 1 < $end && $arr[$son] > $arr[$son + 1])//先比較兩個子節點大小，選擇最大的
            $son++;
        if ($arr[$dad] >= $arr[$son]) {//如果父節點小於子節點時，交換父子內容再繼續子節點和孫節點比較
            self::swap($arr[$dad], $arr[$son]);
            self::max_heapify_desc($arr, $son, $end);
        }
    }

    protected function heap_sort_desc($arr)
    {
        $len = count($arr);
        //初始化，i從最後一個父節點開始調整
        for ($i = $len / 2 - 1; $i >= 0; $i--)
            self::max_heapify_desc($arr, $i, $len);
        //先將第一個元素和已排好元素前一位做交換，再從新調整，直到排序完畢
        for ($i = $len - 1; $i > 0; $i--) {
            self::swap($arr[0], $arr[$i]);
            self::max_heapify_desc($arr, 0, $i);
        }
        return $arr;
    }

    /*
     * 归并排序
     * 算法思想：假设初始具有n个元素，每个子序列的长度为2，然后两两归并，得到下一个子序列，继续两两归并，以此类推。
     * 复杂度：o(n*logn)
     * 辅助空间：o(n)
     * 稳定性：稳定
     * @access public
     * @param string $type 排列顺序：升序asc,降序desc;默认升序asc
     * @return array $array 排序完成的数组
     * @return string $exchange_count 排序过程中交换的次数
     * @return string $compare_count 排序过程中比较的次数
     * */
    public function MergeSort($type = ‘asc‘)
    {
        $array = $this->array;
        $length = $this->length;
        $exchange_count = 0;      //交换次数
        $compare_count = 0;       //比较次数
        switch ($type) {
            case ‘asc‘:
                $array = self::merge_sort_asc($array);
                break;
            case ‘desc‘:
                $array = self::merge_sort_desc($array);
                break;
        }
        return array(
            ‘array‘ => $array,
            ‘exchange_count‘ => $exchange_count,
            ‘compare_count‘ => $compare_count
        );
    }

    protected function merge_sort_asc($arr)
    {
        $len = count($arr);
        if ($len <= 1) {
            return $arr;
        } else {
            $half = ($len >> 1) + ($len & 1);
            $arr2d = array_chunk($arr, $half);
            $left = self::merge_sort_asc($arr2d[0]);
            $right = self::merge_sort_asc($arr2d[1]);
            while (count($left) && count($right)) {
                if ($left[0] < $right[0]) {
                    $reg[] = array_shift($left);
                } else {
                    $reg[] = array_shift($right);
                }
            }
        }
        return array_merge($reg, $left, $right);
    }

    protected function merge_sort_desc($arr)
    {
        $len = count($arr);
        if ($len <= 1) {
            return $arr;
        } else {
            $half = ($len >> 1) + ($len & 1);
            $arr2d = array_chunk($arr, $half);
            $left = self::merge_sort_desc($arr2d[0]);
            $right = self::merge_sort_desc($arr2d[1]);
            while (count($left) && count($right)) {
                if ($left[0] > $right[0]) {
                    $reg[] = array_shift($left);
                } else {
                    $reg[] = array_shift($right);
                }
            }
        }
        return array_merge($reg, $left, $right);
    }

    /*
     * 快速排序
     * 算法思想：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可对这两部分记录继续进行排序，以达到整个序列有序的目的。
     * 复杂度：o(n*logn)
     * 辅助空间：o(logn)~o(n)
     * 稳定性：不稳定
     * @access public
     * @param string $type 排列顺序：升序asc,降序desc;默认升序asc
     * @return array $array 排序完成的数组
     * @return string $exchange_count 排序过程中交换的次数
     * @return string $compare_count 排序过程中比较的次数
     * */
    public function QuickSort($type = ‘asc‘)
    {
        $array = $this->array;
        $length = $this->length;
        static $exchange_count = 0;      //交换次数
        static $compare_count = 0;       //比较次数
        switch ($type) {
            case ‘asc‘:
                $array = self::quick_sort_asc($array);
                break;
            case ‘desc‘:
                $array = self::quick_sort_desc($array);
                break;
        }
        return array(
            ‘array‘ => $array,
            ‘exchange_count‘ => $exchange_count,
            ‘compare_count‘ => $compare_count
        );
    }

    protected function quick_sort_asc($arr)
    {
        $len = count($arr);
        static $compare_count = 0;       //比较次数
        if ($len <= 1) {
            return $arr;
        } else {
            $left = $right = array();
            $mid_value = $arr[0];
            for ($i = 1; $i < $len; $i++) {
                if ($arr[$i] < $mid_value) {
                    $left[] = $arr[$i];
                } else {
                    $right[] = $arr[$i];
                }
                $compare_count++;
            }
        }
        return array_merge(self::quick_sort_asc($left), (array)$mid_value, self::quick_sort_asc($right));
    }

    protected function quick_sort_desc($arr)
    {
        $len = count($arr);
        static $compare_count = 0;       //比较次数
        if ($len <= 1) {
            return $arr;
        } else {
            $left = $right = array();
            $mid_value = $arr[0];
            for ($i = 1; $i < $len; $i++) {
                if ($arr[$i] > $mid_value) {
                    $left[] = $arr[$i];
                } else {
                    $right[] = $arr[$i];
                }
                $compare_count++;
            }
        }
        return array_merge(self::quick_sort_desc($left), (array)$mid_value, self::quick_sort_desc($right));
    }
    /*
     * 排序算法中数组元素交换函数
     * @access protected
     * @param array $array 需要元素交换的数组
     * @param interger $i 需要元素交换的数组下标
     * @param interger $j 需要元素交换的数组下标
     * @return void
     * */
    /*protected function swap(array $array, $i, $j)
    {
        $tmp = $array[$i];
        $array[$i] = $array[$j];
        $array[$j] = $tmp;
    }*/
}

使用示例：(在TP框架下，所以输出均用了dump()函数)

    include ‘/classes/sort.php‘;
    $arr = array(1,5,4,2,9,7,8,6,16,13,14,17);
    $arr = new \SORT($arr);
    echo ‘<h2>冒泡排序结果：</h2>‘;
    echo ‘<h4>升序：</h4>‘;
    $bubble_sort_asc = $arr->BubbleSort(‘asc‘);
    dump($bubble_sort_asc);
    echo ‘<h4>降序：</h4>‘;
    $bubble_sort_desc = $arr->BubbleSort(‘desc‘);
    dump($bubble_sort_desc);
    echo ‘<h2>选择排序结果：</h2>‘;
    echo ‘<h4>升序：</h4>‘;
    $select_sort_asc = $arr->SelectSort(‘asc‘);
    dump($select_sort_asc);
    echo ‘<h4>降序：</h4>‘;
    $select_sort_desc = $arr->SelectSort(‘desc‘);
    dump($select_sort_desc);
    echo ‘<h2>插入排序结果：</h2>‘;
    echo ‘<h4>升序：</h4>‘;
    $insert_sort_asc = $arr->InsertSort(‘asc‘);
    dump($insert_sort_asc);
    echo ‘<h4>降序：</h4>‘;
    $insert_sort_desc = $arr->InsertSort(‘desc‘);
    dump($insert_sort_desc);
    echo ‘<h2>希尔排序结果：</h2>‘;
    echo ‘<h4>升序：</h4>‘;
    $shell_sort_asc = $arr->ShellSort(‘asc‘);
    dump($shell_sort_asc);
    echo ‘<h4>降序：</h4>‘;
    $shell_sort_desc = $arr->ShellSort(‘desc‘);
    dump($shell_sort_desc);
    echo ‘<h2>堆排序结果：</h2>‘;
    echo ‘<h4>升序：</h4>‘;
    $heap_sort_asc = $arr->HeapSort(‘asc‘);
    dump($heap_sort_asc);
    echo ‘<h4>降序：</h4>‘;
    $heap_sort_desc = $arr->HeapSort(‘desc‘);
    dump($heap_sort_desc);
    echo ‘<h2>归并排序结果：</h2>‘;
    echo ‘<h4>升序：</h4>‘;
    $merge_sort_asc = $arr->MergeSort(‘asc‘);
    dump($merge_sort_asc);
    echo ‘<h4>降序：</h4>‘;
    $merge_sort_desc = $arr->MergeSort(‘desc‘);
    dump($merge_sort_desc);
    echo ‘<h2>快速排序结果：</h2>‘;
    echo ‘<h4>升序：</h4>‘;
    $quick_sort_asc = $arr->QuickSort(‘asc‘);
    dump($quick_sort_asc);
    echo ‘<h4>降序：</h4>‘;
    $quick_sort_desc = $arr->QuickSort(‘desc‘);
    dump($quick_sort_desc);

此为第一版，后续还会更新补充。
对于后续三种推排序、归并排序、快速排序，我也还是有点小困惑的。