删除结构体数组中的一组数据_数据结构PHP 输出数组中出现频率最高的前 k 个...

于 2020-12-04 14:06:05 发布
阅读量160 收藏
点赞数
文章标签： 删除结构体数组中的一组数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39724004/article/details/111381234
版权

这篇文章主要是通过一个问题实现过程，选择合适的数据结构，结合之前介绍过的 基于二分搜索树实现的映射(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-elements

2.问题分析

解决问题的思路主要分为两步：

  • 第一步主要是去重，并且需要统计出现元素的次数。

  • 第二步将统计次数出现最高的前 k 个提取出来输出。

  • 尽可能的降低时间复杂度。

2.1 第一步：去重统计分析

若想要统计元素出现的次数，必须要要把全部数组元素遍历一次，此时复杂度为 O(n)，若需要统计元素的次数，则每次出现的时候需要将元素出现的次数 +1 操作，此时最好的更新查找操作是复杂度为 O(logn) 的数据结构，符合这种 key-value 的数据结构，并且能快速查找的数据结构就是 基于二分搜索树实现的映射(Map)，其原理图如下：3e3f7c9e20516b7580319a051544add8.png

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 其目的就是为了保证统计次数有序，其原理图如下：3be25ebafc58c4db8ac26210af2d4ee2.png

Tips：此时可以保持新的 字典(Map)上 value 有序，综合的时间复杂度为 O(nlogn)。

2.2.1 使用基于最小堆维持的 k 个最大元素

遍历映射(Map)，并且将数据转移到只保持 k 个元素的 最小堆 中，若元素比 最小堆 中的最小元素还要大，那么就需要把新元素 替换堆顶，以此类推，达到提取 value 值前 k 个最大元素：aa3e18b94afab25771a36053f078cfcb.png

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 数组类

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

<?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;
    }
}
3.4 output_map.php 输出演示
<?php //require 'LinkedListMap.php';////$map = new LinkedListMap();//$map->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);

输出结果如下：

519ee9b24694c34fcda314909a695ff6.png

代码仓库 ：https://gitee.com/love-for-poetry/data-structure

扫码关注爱因诗贤

f23a970d9dae70fc9f947c994900a1c1.png

weixin_39724004
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值