常见的php排序算法

Posted 2023-05-09

参考技术A

常见的php排序算法

　　本文汇总了常见的php排序算法，在进行算法设计的时候有不错的借鉴价值。现分享给大家供参考之用。具体如下：

　　 一、插入排序

　　用文字简单的描述，比如说$arr = array(4,2,4,6,3,6,1,7,9); 这样的一组数字进行顺序排序：

　　那么，首先，拿数组的第二个元素和第一元素比较，假如第一个元素大于第二元素，那么就让两者位置互换，接下来，拿数组的第三个元素，分别和第二个，第一个元素比较，假如第三个元素小，那么就互换。依次类推。这就是插入排序,它的时间频度是：1+2+...+(n-1)=(n^2)/2。则它的时间复杂度为O(n^2).

　　php实现代码如下：

　　<?phpfunction Sort($arr) $count = count($arr); if($count<2) return $arr; for($i=1;$i<$count;$i++) tmp="$arr[$i];" j="">=0&&$arr[$j]<$arr[$i]) return="">

　　 二、选择排序

　　选择排序用语言描述的话，可以这样,如：$arr = array(4,3,5,2,1);

　　首先,拿第一个和后面所有的比，找出最小的那个数字，然后和第一个数组互换（当然，如果是第一个最小，那么就不用互换了），接着循环，即：拿第二个和后面的比较，找出最小的数字，然后和第二个数字互换，依次类推，也就是说每次都是找出剩余最小的值。 可得到：第一次，时间频度 是n, （第一个和后面的n－1个比较，找到最小的，再看是不是第一个，不是第一个的话进行互换） 在往后，依次是 减一 。 它的时间复杂度，也是O(n^2);

　　php实现代码如下：

　　<?phpfunction selectSort($arr) $count = count($arr); if($count<2) return $arr; for($i=0;$i<$count;$i++) $min=$i; for(j=$i+1;$j<$count;$j++)>$arr[$j]) $min = $j; //找到最小的那个元素的下标 if($min!=$i)//如果下标不是$i 则互换。 $tmp= $arr[$i]; $arr[$i] = $arr[$min]; $arr[$min] = $tmp; return $arr; ?>

　　 三、冒泡排序

　　冒泡排序其实上是和选择排序相比，并无明显差别。都是找到最小的，放到最左端。依次循环解决问题。差别在于冒泡排序的交换位置的次数较多，而选择排序则是找到最小的元素的下标，然后直接和最左端的交换位置。

　　php实现代码如下：

　　<?phpfunction selectSort($arr) $count = count($arr); if($count<2) return $arr; for($i=0;$i<$count;$i++) for(j=$i+1;$j<$count;$j++)>$arr[$j]) $tmp= $arr[$i]; $arr[$i] = $arr[$i]; $arr[$i] = $tmp; return $arr; ?>

　　 四、快速排序

　　快速排序，用语言来形容的话，从数组中选择一个值$a，然后和其余元素进行比较，比$a大的放到数组right中，反之，放到数组left中。然后将left right 分别进行递归调用，即：再细分left right ，最后进行数组的合并。

　　php实现快速排序：

　　<?phpfunction mySort($arr) $count = count($arr); if($count<2) return $arr; $key = $arr[0];//选择第一个元素作为比较元素，可选其他 $left = array(); $right = array(); for($i=1;$i<$count;$i++) key="">=$arr[$i]) $left[] = $arr[$i]; else $right[] = $arr[$i]; $left = mySort($left); $right = mySort($right); $result = array_merge($left,$right); return $result; ?>

　　 五、归并排序

　　其实归并排序是一种拆分，合并的思想。和快速排序思想有共通之处，左边一堆，右边一堆，然后进行合并。通过递归实现排序。 区别之处呢？ 他们的区别也是思想上本质的区别，快速排序的拆分，是选择了特定的值进行大小比较，从而分为left 和 right 。也就是小的一堆放入left，大的一堆放入right。而后，小的left 再细分为left1 right1。。。。通过进行类似的递归完成排序。也就是说，一直细分下去，递归最末尾的left1就是最小值。

　　而归并排序，是从几何上的左右切分，一直递归切分成2或者1的\'最小粒度的数组，然后才开始进行比较大小，然后合并。此处的比较大小是：儿子left的元素 和儿子的right元素 进行比较，而后进行排序合并成为父亲left或者right。在此，直到拿到各自排序合并完成最后两个数组：最起初的left 和right，也仅仅直到他们各自的顺序，并不能确认整个数组的顺序，还是需要通过最终的left right 比较后合并才能完成真正意义上的排序。

　　<?phpfunction gbSort($arr) if(count($arr)<=1)return min="floor(count($arr)/2);//取中间数字进行拆分" left="gbSort($left);" right="gbSort($right);" return="" function="">$right[0] ? array_shift($right) : array_shift($left); //进行比较，小的移除，并且放入到数组$m中。 return arr_merge($m,$left,$right);//进行合并（由于不知道left right 哪个会为空，所以进行统一合并）?>

　　 六、堆排序

　　本例中fixDown函数实现对某一个节点的向下调整，这里默认的是起始节点为1，方便计算父子节点关系

　　注:

　　起始节点为1的父子关系: 父节点k, 子节点为2K、2k+1 子节点j, 父节点为 floor(j/2) floor为向下取整

　　起始节点为0的父子关系: 父节点k, 子节点为2K+1, 2k+2 子节点j, 父节点为 floor((j-1)/2)

　　参数$k为调整点位置, $lenth为数组长度，也就是从1起始到最后一个节点的坐标.

　　<?phpfunction fixDown(&$arr, $k, $lenth)while(2*$k<=$lenth) //只要当前节点有子节点， 就需要继续该循环 $j = $k*2; if ($j<$lenth && $arr[$j]<$arr[$j+1]) $j++; // 只要子节点有右节点，且右节点比左节点大，那么切换到右节点操作。 if ($arr[$j] < $arr[$k]) break; // 如果子节点都没有父节点大， 那么调整结束。 exch($arr[$j], $arr[$k]); $k = $j; function exch(&$a, &$b) $tmp = $a; $a = $b; $b = $tmp;function headSort(&$arr) $len = count($arr); array_unshift($arr, NULL); for($i=$len/2;$i>=1;$i--) fixDown($arr, $i, $len); while($len>1) exch($arr[1], $arr[$len]); fixDown($arr, 1, --$len); array_shift($arr);$arr = array(4,6,4,9,2,3);headSort($arr);?>

　　希望本文所述排序算法实例对大家的php程序设计有所帮助。

;

数据结构常见算法代码实现1-PHP

（1）常用排序算法

Class MySort {

    /*
     * 所有排序均按升序排序
     * */

    /**
     * 插入排序
     * @param $arr
     * @param $st
     * @param $ed
     * 通过将元素插入到已排序的序列中不断扩大已排序的序列
     */
    public function InsertSort(&$arr, $st, $ed) {
        for ($i = $st + 1; $i <= $ed; $i++) {
            $tmp = $arr[$i];
            for ($j = $i - 1; $j >= $st; $j--) {
                if ($arr[$j] > $tmp) { // 如果元素比tmp大，就移动元素
                    $arr[$j + 1] = $arr[$j];
                } else {
                    break;
                }

            }
            $arr[$j + 1] = $tmp;
        }
    }


    /**
     * 冒泡排序
     * @param $arr
     * @param $st
     * @param $ed
     * 通过不断交换相邻元素将更大的元素放在后边，一趟交换之后就能把最大的元素放到最后边，二趟排序可以把次大的元素放在
     * 倒数第二的位置，n趟排序就可以把所有元素都放在正确的位置
     */
    public function BubbleSort(&$arr, $st, $ed) {
        for ($i = $ed - 1; $i >= $st; $i--) {
            $flag = false;
            for ($j = $st; $j <= $i; $j++) {
                if ($arr[$j] > $arr[$j + 1]) {
                    $tmp = $arr[$j];
                    $arr[$j] = $arr[$j + 1];
                    $arr[$j + 1] = $tmp;
                    $flag = true;
                }
            }
            if (!$flag) { // 优化：如果不发生交换，说明已排好序，退出即可
                return;
            }
        }
    }

    /**
     * 选择排序
     * @param $arr
     * @param $st
     * @param $ed
     * 每次选择当前未排序序列最小的元素放在合适的位置，已选择的最小元素构成了已排序序列，不断扩大已排序序列即可实现总体排序
     */
    public function SelectSort(&$arr, $st, $ed) {
        for ($i = $st; $i <= $ed; $i++) {
            $min = $i;
            for ($j = $i; $j <= $ed; $j++) {
                if ($arr[$min] > $arr[$j]) {
                    $min = $j;
                }
            }
            if ($min != $i) {
                $tmp = $arr[$min];
                $arr[$min] = $arr[$i];
                $arr[$i] = $tmp;
            }
        }
    }

    /**
     * 归并排序
     * @param $arr
     * @param $st
     * @param $ed
     * 归并排序的关键在于不断合并两个排好序的序列，可以通过递归实现
     */
    public function MergeSort(&$arr, $st, $ed) {
        if ($st < $ed) {
            $mid = floor(($st + $ed) / 2); // php数值默认使用float型计算，与Java和C不同，所以此处需要向下取整
            $this->MergeSort($arr, $st, $mid);
            $this->MergeSort($arr, $mid + 1, $ed);
            $this->merge($arr, $st, $mid, $ed);
        }
    }

    /**
     * 归并数组arr a1-a2 b1-b2部分
     * @param $arr
     * @param $a1
     * @param $a2
     * @param $b1
     * @param $b2
     */
    private function merge(&$arr, $st, $mid, $ed) {

        $tmp_arr = array();
        $a = $st;
        $b = $mid + 1;
        while ($a <= $mid && $b <= $ed) {
            if ($arr[$a] < $arr[$b]) {
                $tmp_arr[] = $arr[$a];
                $a++;
            }
            else {
                $tmp_arr[] = $arr[$b];
                $b++;
            }
        }
        while ($a <= $mid) {
            $tmp_arr[] = $arr[$a];
            $a++;
        }
        while ($b <= $ed) {
            $tmp_arr[] = $arr[$b];
            $b++;
        }
        for ($i = $st; $i <= $ed; $i++) {
            $arr[$i] = $tmp_arr[$i - $st];
        }
        echo json_encode(func_get_args()) . "***********" . json_encode($tmp_arr) . "\n";
    }

    /**
     * 快速排序
     * @param $arr
     * @param $st
     * @param $ed
     */
    public function QuickSort(&$arr, $st, $ed) {
        if ($st < $ed) {
            $mid = $this->partition($arr, $st, $ed);
            $this->QuickSort($arr, $st, $mid - 1);
            $this->QuickSort($arr, $mid + 1, $ed);
        }
    }

    /**
     * 对数组arr $sd-$ed部分使用轴元素进行划分
     * @param $arr
     * @param $st
     * @param $ed
     * @return mixed
     */
    private function partition(&$arr, $st, $ed) {
        $pivot = $arr[$st];
        while ($st < $ed) {
            while ($st < $ed && $arr[$ed] > $pivot)
                $ed--;
            $arr[$st] = $arr[$ed];
            while ($st < $ed && $arr[$st] <= $pivot)
                $st++;
            $arr[$ed] = $arr[$st];
        }
        $arr[$st] = $pivot;
        return $st;
    }


}

$sort_obj = new MySort();
$arr = [2,9,6,4,0,3,1];
$sort_obj->MergeSort($arr, 0, 6);
var_dump($arr);

（2）二分查找

Class MyFind {

    /**
     * 二分查找
     * @param $arr
     * @param $key
     * PS: 必须保证输入的数组arr是升序排列的！
     */
    public function binarySearch($arr, $key) {
        $st = 0;
        $ed = count($arr) - 1;
        while ($st <= $ed) {
            $mid = floor(($st + $ed) / 2);
            if ($key == $arr[$mid]) {
                return $mid;
            }
            elseif ($key < $arr[$mid]) {
                $ed = $mid - 1;
            }
            else {
                $st = $mid + 1;
            }
        }
        return -1;
    }

    /**
     * 使用递归实现二分查找
     * @param $arr
     * @param $key
     */
    public function binarySearchWithRecursion($arr, $key) {
        return $this->recursion($arr, $key, 0, count($arr) - 1);
    }

    private function recursion($arr, $key, $st, $ed) {
        if ($st > $ed) {
            return -1;
        }
        $mid = floor(($st + $ed) / 2);
        if ($key == $arr[$mid]) {
            return $mid;
        }
        elseif ($key < $arr[$mid]) {
            return $this->recursion($arr, $key, $st, $mid - 1);
        }
        else {
            return $this->recursion($arr, $key, $mid + 1, $ed);
        }
    }

    /**
     * 二叉搜索树查找
     * @param $root
     * @param $key
     * 二叉树结点定义：
     * class ListNode {
     *  public $left;
     *  public $right;
     *  public $value;
     * }
     */
    public function binaryTreeSearch($root, $key) {
        while ($root != null) {
            if ($key == $root->value) {
                return $root;
            }
            elseif ($key < $root->value) {
                $root = $root->left;
            }
            else {
                $root = $root->right;
            }
        }
        return null;
    }

    /**
     * 二分查找不小于$key的最小数（很多算法会用到，比如一致性哈希算法）
     * @param $arr
     * @param $key
     * 进行二分查找时，最后查找的位置总是最接近key的位置，如果key不存在，则最后查找的位置一定是小于key的最大数或者大于key的最小数
     */
    public function binarySearchMinSupper($arr, $key) {
        $st = 0;
        $ed = count($arr) - 1;
        while ($st <= $ed) {
            $mid = floor(($st + $ed) / 2);
            if ($key == $arr[$mid]) {
                return $arr[$mid];
            }
            elseif ($key < $arr[$mid]) {
                $ed = $mid - 1;
            }
            else {
                $st = $mid + 1;
            }
        }
        return $key > $arr[$mid] ? $arr[$mid + 1] : $arr[$mid]; // 此处数组可能越界

    }
}

$find_obj = new MyFind();
$arr = [0,1,2,3,4,6,9];
$a = $find_obj->binarySearchMinSupper($arr, 2.1);
var_dump($a);

 （3）栈与队列（顺序栈、链式栈、顺序队列、链式队列）

abstract Class MyStack {
    protected $capacity = -1;
    public function __construct($capacity = null) {
        if (isset($capacity)) {
            $this->capacity = $capacity;
        }
    }
    abstract public function push($val);
    abstract public function top();
    abstract public function pop();
    abstract public function isEmpty();
    abstract public function isFull();
}
Class MyArrayStack extends MyStack { //顺序栈
    protected $arr = array();
    public function push($val) {
        if ($this->isFull()) {
            return false;
        }
        $this->arr[] = $val;
        return true;
    }
    public function top() {
        return !$this->isEmpty() ? end($this->arr) : null;
    }
    public function pop() {
        return !$this->isEmpty() ? array_pop($this->arr) : null;
    }
    public function isEmpty() {
        return count($this->arr) == 0;
    }
    public function isFull() {
        if ($this->capacity == -1) {
            return false;
        }
        return count($this->arr) == $this->capacity;
    }
}
Class MyLinkedStackNode {
    public $val;
    public $next;
}
Class MyLinkedStack { //链式栈
    protected $pointer = null;
    protected $count = 0;
    public function push($val) {
        if ($this->isFull()) {
            return false;
        }
        $node = new MyLinkedStackNode();
        $node->val = $val;
        $node->next = $this->pointer;
        $this->pointer = $node;
        $this->count++;
        return true;
    }
    public function top() {
        return !$this->isEmpty() ? $this->pointer->val : null;
    }
    public function pop() {
        if ($this->isEmpty()) {
            return null;
        }
        $val = $this->pointer->val;
        $this->pointer = $this->pointer->next;
        $this->count--;
        return $val;
    }
    public function isEmpty() {
        return $this->count == 0;
    }
    public function isFull() {
        if ($this->capacity == -1) {
            return false;
        }
        return $this->count == $this->capacity;
    }
}
abstract Class MyQueue {
    protected $capacity = -1;
    public function __construct($capacity = null) {
        if (isset($capacity)) {
            $this->capacity = $capacity;
        }
    }
    abstract public function enqueue($val);
    abstract public function front();
    abstract public function dequeue();
    abstract public function isEmpty();
    abstract public function isFull();
}
Class MyArrayQueue extends MyQueue {
    protected $arr = array();
    public function enqueue($val)
    {
        if ($this->isFull()) {
            return false;
        }
        $this->arr[] = $val;
        return true;
    }
    public function front()
    {
        return !$this->isEmpty() ? $this->arr[0] : null;
    }
    public function dequeue()
    {
        return !$this->isEmpty() ? array_shift($this->arr) : null;
    }
    public function isEmpty()
    {
        return count($this->arr) == 0;
    }
    public function isFull()
    {
        return count($this->arr) == $this->capacity;
    }
}
Class MyLinkedQueueNode {
    public $val;
    public $next;
}
Class MyLinkedQueue extends MyQueue {
    protected $head = null, $tail = null;
    protected $count = 0;
    public function enqueue($val)
    {
        if ($this->isFull()) {
            return false;
        }
        $node = new MyLinkedQueueNode();
        $node->val = $val;
        if ($this->head == null) { //如果队列为空，效果等同于$this->isEmpty()
            $this->head = $this->tail = $node;
        } else {
            $this->tail->next = $node;
            $this->tail = $this->tail->next;
        }
        return true;
    }
    public function front()
    {
        return !$this->isEmpty() ? $this->head->val : null;
    }
    public function dequeue()
    {
        if ($this->isEmpty()) {
            return null;
        }
        $val = $this->head->val;
        if ($this->head == $this->tail) { //如果只有一个元素
            $this->head = $this->tail = null;
        }
        else {
            $this->head = $this->head->next;
        }
        $this->count--;
        return $val;
    }
    public function isEmpty()
    {
        return $this->count == 0;
    }
    public function isFull()
    {
        return $this->count == $this->capacity;
    }
}