php里面优先级最高的是,数据结构-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;

}

}

扫码关注爱因诗贤