数据结构-PHP 优先级队列（最大堆）的实现

​这篇文章主要介绍如何使用最大堆这种数据结构实现优先队列。

1.优先队列介绍

对于 普通队列，数据元素是 First In First Out，而对于 优先队列 是出队顺序和入队顺序无关，和优先级相关，其特点是 动态的 选择优先级最高的出队。

1.1 完全二叉树图示

把元素顺序排列成树的形状

1.2 最大堆图示

二叉堆是一颗完全二叉树，堆中某个节点的值总是不大于其父亲节点的值，这样就定义出来了 最大堆：

Tips：索引是从 i=1 开始的，左儿子节点索引 left(i) = 2*i，右儿子 right(i) = 2*i+1， 父节点 prent(i) = i/2 求整；

Tips: 若索引是从 i=0 开始的，左儿子 left(i) = 2*i+1，右儿子 right(i) = 2*i+2，parent(i) = (i-1)/2 取整；

1.3 向堆中添加元素 Sift Up 操作

若新添加的元素比父亲节点元素大，则新添加的元素节点需要上浮(sift up)，交换父亲节点和儿子节点的位置，以此类推，继续比较交换之后的父亲节点元素的大小，若儿子比父亲元素大，则交换过程原理图如下：

1.4 从堆中取出最大元素 Sift Down 操作

堆中取出最大元素，其实就是在堆顶取出元素，取出来之后，可以把堆中最后一个元素推到堆顶，然后和儿子节点比较，若小于儿子节点元素，则 堆顶的元素需要 下沉(Sift Down)，交换父亲节点和儿子节点的位置，以此类推，继续比较交换之后的儿子节点元素的大小，则交换过程原理图如下：

1.5 优先队列的复杂度简对比

对于 普通线性结构来说，入队操作时间复杂度看做O(1)，出队时间复杂度看做 O(n)，而对于 顺序线性结构 来说，入队操作时间复杂度看做 O(n)，出队 时间复杂度看做 O(1)，对于 最大堆 来说 入队 操作时间复杂度看做O(logn)，出队 操作时间复杂度看做 O(logn)，综上所述，若使用 堆 数据结构实现 优先队列 更加合理。

2.代码实现

2.1 MaxHeap 最大堆

这是一个基于数组实现的 最大堆，其中 add($e) 表示向堆中添加元素，siftUp() 方法表示上浮(Sift Up)元素，getMax() 方法表示取出堆中最大元素，siftDown() 方法表示下沉元素：

<?php
require "ArrayStruct.php";
class MaxHeap
{
    private $array = null;
    /**
     * 构造函数 初始化堆的容量
     * MaxHeap constructor.
     * @param int $capacity
     */
    public function __construct(int $capacity = 10) {
        $this->array = new ArrayStruct($capacity);
    }
    /**
     * 返回堆的元素个数
     * @return int
     */
    public function getSize(): int {
        return $this->array->getSize();
    }
    /**
     * 判断堆是否为空
     * @return bool
     */
    public function isEmpty(): bool {
        return $this->array->isEmpty();
    }
    /**
     * 计算某个索引 $i 节点父亲节点索引值 $i父+1 = ($i+1)/2 取整，即 $i父 = ($i-1)/2 取整
     * @param $i
     * @return int
     */
    private function parent($i): int {
        if ($i == 0) {
            echo "索引 0 是没有父亲节点的";
            exit;
        }
        return (int)(($i - 1) / 2);
    }
    /**
     * 计算某个索引 $i 节点左儿子节点索引值 $i左+1 = ($i+1)*2 取整，即 $i左 = 2*$i+1
     * @param $i
     * @return int
     */
    private function leftSon($i): int {
        return $i * 2 + 1;
    }
    /**
     * 计算某个索引 $i 节点右儿子节点索引值 $i右+1 = ($i+1)*2+1 取整，即 $i左 = 2*$i+2
     * @param $i
     * @return int
     */
    private function rightSon($i): int {
        return $i * 2 + 2;
    }
    /**
     * 向堆中添加元素
     * @param $e
     */
    public function add($e): void {
        $this->array->addLast($e);
        $this->siftUp($this->array->getSize() - 1);
    }
    /**
     * 元素上浮
     * @param $i
     */
    private function siftUp($i) {
        while ($i > 0 && $this->array->get($this->parent($i)) < $this->array->get($i)) {
            $this->swsp($i, $this->parent($i));
            $i = $this->parent($i);
        }
    }
    /**
     * 元素下沉
     * @param $i
     */
    private function siftDown($i) {
        while ($i < $this->array->getSize() && ($this->array->get($this->leftSon($i)) > $this->array->get($i) || $this->array->get($this->rightSon($i)) > $this->array->get($i))) {
            if ($this->array->get($this->leftSon($i)) < $this->array->get($this->rightSon($i))) {
                $this->swsp($i, $this->rightSon($i));
                $i = $this->rightSon($i);
            } else {
                $this->swsp($i, $this->leftSon($i));
                $i = $this->leftSon($i);
            }
        }
    }
    /**
     * 查看堆中最大的元素
     * @return mixed
     */
    public function findMax() {
        if ($this->array->isEmpty()) {
            echo "堆是空的";
            exit;
        }
        return $this->array->get(0);
    }
    public function getMax() {
        $max = $this->findMax();
        //删除操作
        if ($this->array->getSize() > 1) {
            $this->array->set(0, $this->array->removeLast());
            $this->siftDown(0);
        }
        return $max;
    }
    /**
     * 交换堆中元素值
     */
    public function swsp($i, $parentI) {
        $parentE = $this->array->get($parentI);
        $e = $this->array->get($i);
        $this->array->set($i, $parentE);
        $this->array->set($parentI, $e);
    }
    public function toString() {
        return $this->array->toString();
    }
}

2.2 ArrayStruct 数组类

这是一个数组类，能实现基本数组元素的增删改查操作，并且动态扩容：

<?php
/**
 * 数据结构-数组的实现
 * Class ArrayStruct
 */
class ArrayStruct
{
    //用于存放数据
    protected $data = [];
    //用于标记数组大小
    protected $size = 0;
    //用于标记数组的容量
    protected $capacity = 10;
    /**
     * 构造函数 定义数组容量
     * ArrayStruct constructor.
     * @param int $capacity
     */
    public function __construct(int $capacity = 10) {
        $this->capacity = $capacity;
    }
    /**
     * 获取数组元素个数
     * @return int
     */
    public function getSize(): int {
        return $this->size;
    }
    /**
     * 获取数组的容量
     * @return int
     */
    public function getCapacity(): int {
        return $this->capacity;
    }
    /**
     * 判断数组是否为空
     * @return bool
     */
    public function isEmpty(): bool {
        return $this->size == 0;
    }
    /**
     * 向数组指定位置插入元素
     * @param int $index
     * @param $e
     * @throws Exception
     */
    public function add(int $index, $e): void {
        if ($this->size == $this->capacity) {
            $this->resize(2); //扩大到原来的2倍
        }
        if ($index < 0 || $index > $this->size) {
            echo "添加位置超出数组大小";
            exit;
        }
        //为了方便理解，[1,2,4,5,6],假设 $index = 3; $e = 100,插入之后[1,2,4,100,5,6]
        for ($i = $this->size; $i >= $index; $i--) {
            $this->data[$i] = $this->data[$i - 1];
        }
        $this->data[$index] = $e;
        $this->size++;
    }
    public function set($index, $e) {
        if ($index < 0 || $index > $this->size) {
            echo "添加位置超出数组范围";
            exit;
        }
        $this->data[$index] = $e;
    }
    /**
     * 向数组末尾添加元素
     * @param $e
     * @throws Exception
     */
    public function addLast($e): void {
        $this->add($this->size, $e);
    }
    /**
     * 向数组开头插入元素
     * @param $e
     * @throws Exception
     */
    public function addFirst($e): void {
        $this->add(0, $e);
    }
    /**
     * 获取 index 位置数组元素
     * @param int $index
     * @return mixed
     */
    public function get(int $index) {
        if ($index < 0 || $index > $this->size) {
            echo "index值超出元素的位置范围，";
            exit;
        }
        return $this->data[$index];
    }
    /**
     * 获取数组末尾元素
     * @return mixed
     */
    public function getLast() {
        return $this->get($this->size - 1);
    }
    /**
     * 获取数组开头元素
     * @return mixed
     */
    public function getFirst() {
        return $this->get(0);
    }
    /**
     * 判断数组中是否存在某个元素
     * @param $e
     * @return bool
     */
    public function contains($e): bool {
        for ($i = 1; $i < $this->size; $i++) {
            if ($this->data[$i] == $e) {
                return true;
            }
        }
        return false;
    }
    /**
     * 查某个元素在数组的位置索引值，若不存在则返回 -1
     * @param $e
     * @return int
     */
    public function find($e): int {
        for ($i = 0; $i < $this->size; $i++) {
            if ($this->data[$i] == $e) {
                return $i;
            }
        }
        return -1;
    }
    /**
     * 删除数组指定位置元素，返回删除元素的值
     * @param $index
     * @return mixed
     */
    public function remove($index) {
        if ($index < 0 || $index > $this->size) {
            echo "index值超出元素的位置范围，";
            exit;
        }
        $e = $this->data[$index];
        for ($i = $index; $i < $this->size - 1; $i++) {
            $this->data[$i] = $this->data[$i + 1];
        }
        $this->size--;
        $this->data[$this->size] = null;  //loitering objects ! =memory
        /** 若当前数组大小，小于容量的一半，则重新分配一半的数组空间大小 **/
        if ($this->size <= $this->capacity / 4 && $this->capacity % 2 == 0) {
            $this->resize(0.5);
        }
        return $e;
    }
    /**
     * 删除数组首个元素，返回删除元素的值
     */
    public function removeFirst() {
        return $this->remove(0);
    }
    /**
     * 删除数组首个元素，返回删除元素的值
     */
    public function removeLast() {
        return $this->remove($this->size - 1);
    }
    /**
     * 删除数组中特定元素
     * @param $e
     */
    public function removeElement($e) {
        for ($i = 0; $i < $this->size; $i++) {
            if ($this->data[$i] == $e) {
                $this->remove($i);
                $this->removeElement($e);
                break;
            }
        }
    }
    /**
     * 数组扩容，若是其他语言，如JAVA这里需要重新开辟空间
     * @param $factor
     */
    protected function resize($factor) {
        $this->capacity = $factor * $this->capacity;
    }
    /**
     * 将数组转化为字符串
     * @return string
     */
    public function toString(): string {
        $str = "[";
        for ($i = 0; $i < $this->size; $i++) {
            $value_str = is_numeric($this->data[$i]) ? $this->data[$i] : "'{$this->data[$i]}'";
            $str       .= $i . " => " . $value_str . ",";
        }
        $str = trim($str, ",");
        $str .= "]";
        return $str;
    }
}

代码仓库 ：https://gitee.com/love-for-po...

扫码关注爱因诗贤