这篇文章主要是通过一个问题实现过程，选择合适的数据结构，结合之前介绍过的 基于二分搜索树实现的映射(Map) 和 最小堆两种数据结构，可以将问题实现过程的时间复杂度降低。
1. 问题描述
给定一个非空的整数数组，返回其中出现频率前 k 高的元素。
示例 1:
输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
示例 2:
输入: nums = [1], k = 1
输出: [1]
提示：
你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。
你的算法的时间复杂度必须优于 O(n log n) , n 是数组的大小。
题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的。
你可以按任意顺序返回答案。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/top-k-frequent-elements2.问题分析
解决问题的思路主要分为两步：
- 第一步主要是去重，并且需要统计出现元素的次数。
- 第二步将统计次数出现最高的前 k 个提取出来输出。
- 尽可能的降低时间复杂度。
2.1 第一步：去重统计分析
若想要统计元素出现的次数，必须要要把全部数组元素遍历一次，此时复杂度为 O(n)，若需要统计元素的次数，则每次出现的时候需要将元素出现的次数 +1 操作，此时最好的更新查找操作是复杂度为 O(logn) 的数据结构，符合这种 key-value 的数据结构，并且能快速查找的数据结构就是 基于二分搜索树实现的映射(Map)，其原理图如下：
Tips：若该二分搜索树上已经存在元素key，添加相同key的时候只需要将value值+1，这样保证了数据的查找速度，也能保证统计出现频率的作用。此时综合的时间复杂度为O(nlogn)。
2.2 第二步：选出上述二分搜索树中统计次数最大的前 k 个
2.2.1 使用基于二分搜索树的 Map 排序
遍历映射(Map)，并且将数据转移到另外一个 新的基于二分搜索树实现的映射(Map)，但此时 key 和 value 的值对调，比如原理 key=3，value=5 表示 3 统计的次数是 5，转移到新的 Map 上 key=5,value=3 其目的就是为了保证统计次数有序，其原理图如下：
Tips：此时可以保持新的字典（Map）上value有序，综合的时间复杂度为O(nlogn)。
2.2.1 使用基于最小堆维持的 k 个最大元素
遍历映射(Map)，并且将数据转移到只保持 k 个元素的 最小堆 中，若元素比 最小堆 中的最小元素还要大，那么就需要把新元素 替换堆顶，以此类推，达到提取 value 值前 k 个最大元素：
Tips：图中最小堆展示的是出现次数频率最高的前k个频率数，其实存储可以使用["value" => 3,"count" => "7"]这种格式去存储，综合时间复杂度为O(nlogk)，这个复杂度比O(nlogn)要小。
3.PHP 代码
3.1 BinarySearchTreeMap 基于二分搜索树的映射(Map)
该类中add() 可以向数据中添加 key-value，get() 方法可以获取 key 对于的 value，set() 方法可以更新 key 对于的 value 值，traverseMinHeap() 方法可以将 Map 中的数据转移到 最小堆 中，并保持前 k 个最大:
class BinarySearchTreeMap implements Map
{
public $root;
public $size;
public function __construct() {
$this->root = null;
$this->size = 0;
}
/**
* 获取映射(Map)中某个key对应的value
* @param $key
* @return |null
*/
public function get($key) {
$node = $this->recursionGet($key, $this->root);
return $node == null ? null : $node->value;
}
/**
* 递归获取 key 对应的节点
* @param $key
* @param $root
* @return |null
*/
private function recursionGet($key, $root) {
if ($root == null) {
return null;
} elseif ($key == $root->key) {
return $root;
} elseif ($key < $root->key) {
return $this->recursionGet($key, $root->left);
} else {
return $this->recursionGet($key, $root->right);
}
}
/**
* 添加 key-value 数据
* @param $key
* @param $value
*/
public function add($key, $value): void {
$this->root = $this->recursionAdd($key, $value, $this->root);
}
/**
* 递归添加数据
* @param $key
* @param $value
* @param $root
*/
private function recursionAdd($key, $value, $root) {
if ($root == null) {
$root = new Node($key, $value);
$this->size++;
} elseif ($key == $root->key) {
$root->value = $value;
} elseif ($key < $root->key) {
$root->left = $this->recursionAdd($key, $value, $root->left);
} else {
$root->right = $this->recursionAdd($key, $value, $root->right);
}
return $root;
}
/**
* 查看map是否包含某个key
* @param $key
* @return bool
*/
public function contains($key): bool {
$node = $this->recursionGet($key, $this->root);
return $node != null;
}
/**
* 递归查看map是否存在某个 key
* @param $key
* @param $root
* @return bool
*/
private function recursionContains($key, $root) {
if ($root == null) {
return false;
} elseif ($key == $root->key) {
return true;
} elseif ($key < $root->key) {
return $this->recursionContains($key, $root->left);
} else {
return $this->recursionContains($key, $root->right);
}
}
/**
* 修改 key 对应的 value
* @param $key
* @param $value
*/
function set($key, $value) {
$node = $this->recursionGet($key, $this->root);
if ($node == null) {
echo "不存在该节点";
exit;
}
$node->value = $value;
}
public function traverseMinHeap($minHeap, $k) {
$this->recursionTraverse($this->root, $minHeap, $k);
}
private function recursionTraverse($root, $minHeap, $k) {
if ($root != null) {
$this->recursionTraverse($root->left, $minHeap, $k);
if ($minHeap->getSize() < $k) {
$minHeap->add(['key' => $root->key, 'value' => $root->value]);
} else {
$min = $minHeap->findMin();
if ($root->value > $min['value']) {
$minHeap->replaceMin(['key' => $root->key, 'value' => $root->value]);
}
}
$this->recursionTraverse($root->right, $minHeap, $k);
}
}
/**
* 获取映射 Map 中 key-value 数量
* @return int
*/
public function getSize(): int {
return $this->size;
}
}
class Node
{
public $key;
public $value;
public $left = null;
public $right = null;
public function __construct($key, $value) {
$this->key = $key;
$this->value = $value;
}
}3.2 MinHeap 最小堆
这是一个基于数组类(ArrayStruct) 实现的 最小堆，每个节点包含 key 和 value 两个属性，其中 key 表示频率，value 表示元素值，上浮(siftUp) 和 下沉（siftDown） 操作是基于 key 值比较的：
class MinHeap
{
private $array = null;
/**
* 构造函数 初始化堆的容量
* MinHeap 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))['value'] > $this->array->get($i)['value']) {
$this->swsp($i, $this->parent($i));
$i = $this->parent($i);
}
}
/**
* 元素下沉
* @param $i
*/
private function siftDown($i) {
while ($i < $this->array->getSize() / 2) {
$leftSon = $this->array->get($this->leftSon($i));
$rightSon = $this->array->get($this->rightSon($i));
if (!empty($leftSon) && empty($rightSon) && $this->array->get($i)["value"] > $leftSon["value"]) {
$this->swsp($i, $this->leftSon($i));
$i = $this->leftSon($i);
} elseif (empty($leftSon) && !empty($rightSon) && $this->array->get($i)["value"] > $rightSon["value"]) {
$this->swsp($i, $this->rightSon($i));
$i = $this->rightSon($i);
} elseif (!empty($leftSon) && !empty($rightSon) && ($this->array->get($i)["value"] > $rightSon["value"] || $this->array->get($i)["value"] > $leftSon["value"])) {
if ($rightSon["value"] > $leftSon["value"]) {
$this->swsp($i, $this->leftSon($i));
$i = $this->leftSon($i);
} else {
$this->swsp($i, $this->rightSon($i));
$i = $this->rightSon($i);
}
} else {
break;
}
}
}
/**
* 查看堆中最大的元素
* @return mixed
*/
public function findMin() {
if ($this->array->isEmpty()) {
echo "堆是空的";
exit;
}
return $this->array->get(0);
}
public function getMin() {
$max = $this->findMin();
$this->array->set(0, $this->array->removeLast());
//删除操作
if ($this->array->getSize() > 1) {
$this->siftDown(0);
}
return $max;
}
public function replaceMin($e) {
$min = $this->findMin();
$this->array->set(0, $e);
$this->siftDown(0);
return $min;
}
/**
* 交换堆中元素值
*/
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();
}
}3.3 ArrayStruct 数组类
这是一个数组类，能实现基本数组元素的增删改查操作，并且动态扩容：
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;
}
}3.4 output_map.php 输出演示
add("school","wuhan");
//$map->add("name","爱因诗贤");
//$map->add("age",18);
//$map->add("weight",65);
//$map->remove("school");
//
//print_r($map);
require 'BinarySearchTreeMap.php';
require $root . "/MinHeap/MinHeap.php";
$nums = [5,-3,9,1,7,7,9,10,2,2,10,10,3,-1,3,7,-9,-1,3,3];
$k = 3;
$map = new BinarySearchTreeMap();
foreach ($nums as $key) {
$value = $map->get($key);
if ($value != null) {
$map->set($key, $value + 1);
} else {
$map->add($key, 1);
}
}
$minHeap = new MinHeap();
$map->traverseMinHeap($minHeap, $k);
//print_r($minHeap);
$reArr = [];
while (!$minHeap->isEmpty()) {
$arr = $minHeap->getMin();
$reArr[] = $arr["key"];
}
print_r($reArr);
输出结果如下：
代码仓库 ：https://gitee.com/love-for-po...
扫码关注爱因诗贤
