排序算法

前段时间收集了一些排序算法，并且通过自己的方式实现这些算法，下面直接展示各种算法

排序方法类

个人习惯比较喜欢直接写成类的方式，可能是受到Java影响，比较喜欢将同类型方法集合到类中，也比较方便方法调用，有问题的话欢迎来评论区评论

<?php

namespace Sort;

/**
 * Class Sort
 * @package Sort
 * 对一维数组进行排序
 */
class Sort
{

    /**
     * 选择排序
     * 在要排序的一组数中，选出最小的一个数与第一个位置的数交换。然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
     * @param array $arr
     * @return array
     */
    public static function selectSort(array $arr)
    {
        $len = count($arr);
        for ($i = 0;$i< $len -1;$i++)
        {
            $p = $i;
            for ($j = $i+1;$j<$len;$j++)
            {
                if( $arr[$j] < $arr[$p] )
                {
                    $p = $j;
                }
            }
            if( $i != $p )
            {
                $temp = $arr [$p];
                $arr[$p] = $arr[$i];
                $arr[$i] = $temp;
            }
        }
        return $arr;
    }
    /**
     * 快速排序
     * 假设有数组已经排好序，现插入一个元素，从数组末尾开始比较，直至找到合适的位置插入数组
     * @param array $arr
     * @return array
     */
    public static function insertSort(array $arr)
    {
        $len = count($arr);
        for ($i = 1;$i<$len;$i++)
        {
            $temp = $arr[$i];
            $j = $i-1;
            while($j>=0 && $temp > $arr[$j])
            {
                $arr[$j+1] = $arr[$j--];
            }
            $arr[$j+1] = $temp;
        }
        return $arr;
    }
    /**
     * 冒泡排序算法
     * @param Array $array 需要排序的一维数组
     * @param Boolean $flag  true 升序 false 降序
     * @return Array Or -1
     */
    public static function bubbleSort(Array $array, bool $flag = true)
    {
        if( !self::_isSingleDimensionArray($array) )
        {
            return -1;
        }
        $len = count($array);
        for ( $i = 0; $i < $len; $i ++ )
        {
            for ($j = $i; $j < $len; $j ++ )
            {
                if( self::_compare($array[$i],$array[$j],$flag) )
                {
                    $temp = $array [$i];
                    $array[$i] = $array[$j];
                    $array[$j] = $temp;
                }
            }
        }
        return $array;
    }

    /**
     * 改进冒泡排序算法，在一定的情况下，会减少比较次数
     * 优点：一定条件是指，在排序进行到一定次数时，数据排序已完成，不在需要继续进行比较
     * 缺点：多了一步 判断，当有一个完全紊乱的数组时，耗费时间相对较长
     * @param Array $array 需要排序的一维数组
     * @param Boolean $flag  true 顺序 false 倒序
     * @return Array Or -1
     */
    public static function optimizeBubbleSort(Array $array, bool $flag = true)
    {
        if( !self::_isSingleDimensionArray($array) )
        {
            return -1;
        }
        $len = count($array);
        for ( $i = 0; $i < $len; $i ++ )
        {
            $tag = false;
            for ($j = $i; $j < $len; $j ++ )
            {
                if( self::_compare($array[$i],$array[$j],$flag) )
                {
                    $tag = true;
                    $temp = $array [$i];
                    $array[$i] = $array[$j];
                    $array[$j] = $temp;
                }
            }
            if( !$tag )
            {
                break;
            }
        }

        return $array;
    }

    /**
     * 快速排序
     * @param Array $array 需要排序的一维数组
     * @param Boolean $flag  true 顺序 false 倒序
     * @return Array Or -1
     */
    public static function quickSort(Array $array, bool $flag = true)
    {
        if( !self::_isSingleDimensionArray($array) )
        {
            return -1;
        }

        $len = count($array);
        if( $len <= 1)
        {
            return $array;
        }
        $left_array = [];
        $right_array = [];

        for ($i=1;$i<$len;$i++)
        {
            if( self::_compare($array[0],$array[$i],$flag) )
            {
                array_push($left_array,$array[$i]);
            } else {
                array_push($right_array,$array[$i]);
            }
        }

        $left_array = self::quickSort($left_array,$flag);
        $right_array = self::quickSort($right_array,$flag);

        return array_merge($left_array,[$array[0]],$right_array);

    }

    /**
     * 判断数组是否为一维数组
     * @v1.0
     * @param Array $array 变量
     * @return Boolean true Or false
     */
    private static function _isSingleDimensionArray(Array $array)
    {
        return count($array) == count($array, 1);
    }

    /**
     * 比较大小
     * @v1.0
     * @param Number $val1 需要比较的数值
     * @param Number $val2 需要比较的数值
     * @param Boolean $flag 标识 true '>'， false '<'
     * @return Boolean true Or false
     */
    private static function _compare($val1,$val2,$flag)
    {
        return $flag ? $val1>=$val2 : $val1<$val2;
    }
}

最近开始有意识的去收集看到的各种算法，并且已上传到码云上，有兴趣的可以下载来看看，地址：git@gitee.com:zhao_wei_cai/algorithm.git
注释：
本文部分借鉴了 Raylove 的文章，原文地址：https://www.cnblogs.com/a609251438/p/11845846.html