LeetCode·每日一题·1801.积压订单中的订单总数·优先队列

最新推荐文章于 2023-11-30 11:16:03 发布
最新推荐文章于 2023-11-30 11:16:03 发布
阅读量709 收藏 1
点赞数 1
分类专栏： LeetCode刷题笔记 文章标签： leetcode 哈希算法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64560763/article/details/128519677
版权

作者：小迅
链接：https://leetcode.cn/problems/number-of-orders-in-the-backlog/solutions/2041265/you-xian-dui-lie-zhu-shi-chao-ji-xiang-x-ln8c/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 

题目

 

示例

 

思路

阅读理解题，读着确实难受，不过还挺有意义的。 其实题目描述的就是“价格优先”的竞价规则。 所谓“价格优先”，就是优先成交“出价最高”的“买方”和“出价最低”的“卖方”。 股票市场以及steam里的市场都将这个原则放在第一位。 所谓“积压订单”，就是一个订单池，买方出价和卖方要价没有重叠（否则立即成交）。 我们要根据价格优先原则维护这些订单的“优先级”，很自然地想到 优先队列 。 买方出价越高，优先级越高，所以用大顶堆维护，与之相反，卖方订单用小顶堆维护。 每遇到一个新的订单，就与订单池中另一方的优先级最高的订单（堆顶）比较，并尝试进行交易，直到没有订单可以交易。 维护订单池中的订单数，根据出入调整，最后返回即可

优先队列的实现，我们可以使用队列，堆，哈希表或者数组实现，对于本题 可以使用 大顶堆记录买、小顶堆记录卖来实现优先队列也可以使用哈希表来实现优先队列。

对于哈希表可以使用力扣支持的库实现，不会的可以看看哈希表库实现

代码

//哈希表实现优先队列
int hashSortSell(int* a, int* b){
    return *a > *b;
}

int hashSortBuy(int* a, int* b){
    return *a < *b;
}

typedef struct{
    int price;
    int amount;
    UT_hash_handle hh;
} hashMap;

#define MOD 1000000007

int getNumberOfBacklogOrders(int** orders, int ordersSize, int* ordersColSize){
   //可以哈希表建立buy的降序排列表，sell的升序排列表
    hashMap* buyItem = NULL;
    hashMap* sellItem = NULL;
    hashMap* tmp = NULL;
    hashMap* cur = NULL;
    for(int i = 0; i < ordersSize;i++){
        if(orders[i][2] == 0){
            //buy
            HASH_ITER(hh,sellItem,cur,tmp){
                if(cur && cur->price <= orders[i][0]) {
                    if (cur->amount >= orders[i][1]) {
                        cur->amount -= orders[i][1];
                        //该sell项目可以剔除
                        if (cur->amount == 0) {
                            HASH_DEL(sellItem,cur);
                        }
                        orders[i][1] = 0;
                        break;
                    } else {
                        orders[i][1] -= cur->amount;
                        HASH_DEL(sellItem, cur);
                    }
                } else {
                    //没有找到可以处理的项目,退出
                    break;
                }
            }

            //将该项目加入哈希表中
            HASH_FIND_INT(buyItem,&orders[i][0],tmp);
            if(tmp == NULL) {
                tmp = malloc(sizeof(hashMap));
                tmp->price = orders[i][0];
                tmp->amount = orders[i][1];
                HASH_ADD_INORDER(hh, buyItem, price, sizeof(int), tmp, hashSortBuy);
            } else {
                tmp->amount += orders[i][1];
            }
        } else {
            //sell
            HASH_ITER(hh,buyItem,cur,tmp){
                if(cur && cur->price >= orders[i][0]) {
                    if (cur->amount >= orders[i][1]) {
                        cur->amount -= orders[i][1];
                        //该buy项目可以剔除
                        if (cur->amount == 0) {
                            HASH_DEL(buyItem,cur);
                        }
                        orders[i][1] = 0;
                        break;
                    } else {
                        orders[i][1] -= cur->amount;
                        HASH_DEL(buyItem, cur);
                    }
                } else {
                    //没有找到可以处理的项目,退出
                    break;
                }
            }

            //将该项目加入哈希表中
            HASH_FIND_INT(sellItem,&orders[i][0],tmp);
            if(tmp == NULL) {
                tmp = malloc(sizeof(hashMap));
                tmp->price = orders[i][0];
                tmp->amount = orders[i][1];
                HASH_ADD_INORDER(hh, sellItem, price, sizeof(int), tmp, hashSortSell);
            } else {
                tmp->amount += orders[i][1];
            }
        }
    }

    int ret = 0;
    HASH_ITER(hh,buyItem,cur,tmp){
        if(cur){
            ret = (ret + cur->amount)%MOD;
            HASH_DEL(buyItem,cur);
            free(cur);
        }
    }

    HASH_ITER(hh,sellItem,cur,tmp){
        if(cur){
            ret = (ret + cur->amount)%MOD;
            HASH_DEL(sellItem,cur);
            free(cur);
        }
    }
    
    return ret%MOD;
}


作者：小迅
链接：https://leetcode.cn/problems/number-of-orders-in-the-backlog/solutions/2041265/you-xian-dui-lie-zhu-shi-chao-ji-xiang-x-ln8c/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
//堆实现优先队列
//代码示例   标准堆 存储数据
typedef struct Heap
{
    long long * array;   //存放堆的数组
    long long * num;
    int  capacity;//数组的容量
    int  len;     //已存数组的大小
}Heap;
//#define maxHeap                                         /*大小根堆切换开关*/
int  HeapLen(Heap* hp);                                 //heap获取当前的堆大小
void HeapSwap(long long * pLeft, long long * pRight);                 //heap交换父子结点的数值
bool HeapEmpty(Heap* hp);                               //heap判空
bool HeapFull(Heap* hp);                                //heap判满
long long   HeapGetTop(Heap* hp);                              //heap获取堆顶
void HeapInsert(Heap* hp, long long   dat,long long  num);            //heap向堆的尾部插入1个元素
void HeapDelete(Heap* hp);                              //heap删除堆顶
void HeapAdjustDown(Heap* hp, int parent);              //heap向下调整
void HeapAdjustUp(Heap* hp, int child);                 //heap向上调整
Heap* CreateHeap( int size);                            //heap创建
void heapFree(Heap* hp);                                //heap释放空间
bool maxHeap;

int HeapLen(Heap* hp)
{
    return hp->len;
}

bool HeapEmpty(Heap* hp)          //判空
{
    if (HeapLen(hp) == 1)
    {
        return true;
    }
    return false;
}

bool HeapFull(Heap* hp)          //判满
{
    if (hp->capacity == hp->len)
    {
        return true;
    }
    return false;
}

void HeapSwap(long long * pLeft, long long * pRight)//交换数值
{
    //交换堆中的父子结点
    long long   temp;
    temp = *pLeft;
    *pLeft = *pRight;
    *pRight = temp;
}

long long  HeapGetTop(Heap* hp)
{
    return hp->array[1];
}

void HeapDelete(Heap* hp)//删除堆顶
{
    if (HeapEmpty(hp))
        return;

    //用最后一个元素覆盖堆顶，相当于删除堆顶
    hp->array[1] = hp->array[hp->len - 1];
    hp->num[1]   = hp->num[hp->len - 1];
    hp->len--;//删除最后一个元素 heap长度变短
    HeapAdjustDown(hp, 1);//对第一个元素进行调整
}

void HeapInsert(Heap* hp, long long   dat,long long  num)
{
    if (HeapFull(hp))
        return;
    int child = 0;
    int parent = 0;
    //插入到最后一个元素的下一个位置
    hp->array[hp->len] = dat;
    hp->num[hp->len] = num;
    hp->len++;
    //调整刚插入元素，
    //因为插入的是堆的尾部，需要堆向上调整
    HeapAdjustUp(hp, hp->len - 1);
}

Heap* CreateHeap( int size)//创建
{
    Heap* heap = (Heap*)malloc(sizeof(Heap));
    int   heapLen = size + 1;//长度比size的长度大1才行
    //给堆申请空间,初始化
    heap->array = (long long *)malloc(sizeof(long long ) * heapLen);
    heap->num = (long long *)malloc(sizeof(long long ) * heapLen);

    heap->capacity = heapLen;     //容量
    heap->len = 1;     //当前大小
    return heap;
}

void HeapAdjustDown(Heap* hp, int parent)//向下调整
{
    //标记左右孩子中最小孩子
    int child = 2 * parent;            //左孩子为2*parent  右孩子为 2*parent +1
    int len = hp->len;

    while (child < len)
    {
        if( maxHeap)      
        {
            //大根堆 选最大的
            //有右子树时 ，找左右孩子中最大的孩子 
            if ((child + 1 < len) && hp->array[child] < hp->array[child + 1])
                child = child + 1;

            //最大孩子大于双亲时 ，孩子与双亲数值交换，否则说明已经调好，不用继续
            if (hp->array[child] > hp->array[parent])
            {
                HeapSwap(&hp->array[child], &hp->array[parent]);
                HeapSwap(&hp->num[child], &hp->num[parent]);
                parent = child;
                child = parent << 1;
            }
            else
            {
                return;
            }
        }
        else
        {
            //小根堆  选最小的
            //有右子树时 ，找左右孩子中最小的孩子 
            if ((child + 1 < len) && hp->array[child] > hp->array[child + 1])
                child = child + 1;

            //最小孩子小于双亲时 ，孩子与双亲数值交换，否则说明已经调好，不用继续
            if (hp->array[child] < hp->array[parent])
            {
                HeapSwap(&hp->array[child], &hp->array[parent]);
                HeapSwap(&hp->num[child], &hp->num[parent]);
                parent = child;
                child = parent << 1;
            }
            else
                return;
        }
    }
}

void HeapAdjustUp(Heap* hp, int child)//向上调整
{
    //得到父母结点的位置
    int parent = child / 2;
    
    if( maxHeap)    
    {
        //大根堆选择大的
        //循环迭代从child当前位置一直迭代到0位置即对顶
        while (child > 1)
        {
            if (hp->array[child] > hp->array[parent])
            {
                HeapSwap(&hp->array[child], &hp->array[parent]);
                HeapSwap(&hp->num[child], &hp->num[parent]);
                child = parent;
                parent = child/2;
            }
            else
                return;
        }
    }
    else
    {
        //小根堆选择小的
        //循环迭代从child当前位置一直迭代到0位置即对顶
        while (child > 1)
        {
            if (hp->array[child] < hp->array[parent])
            {
                HeapSwap(&hp->array[child], &hp->array[parent]);
                HeapSwap(&hp->num[child], &hp->num[parent]);
                child = parent;
                parent = child/2;
            }
            else
                return;
        }
    }
}

void heapFree(Heap* hp)
{
    free(hp->array);
    free(hp);
}

int getNumberOfBacklogOrders(int** orders, int ordersSize, int* ordersColSize)
{
    //买最大堆
    //卖最小堆
    Heap * buyHeap  = CreateHeap(ordersSize);
    Heap * sellHeap = CreateHeap(ordersSize);
    for(int i = 0; i<ordersSize; i++)
    {
        if(orders[i][2] == 1)
        {
            //卖 最小堆
            maxHeap = false;
            HeapInsert(sellHeap, (long long )orders[i][0], (long long )orders[i][1]);
        }
        else
        {
            //买 最大堆
            maxHeap = true;
            HeapInsert(buyHeap, (long long )orders[i][0], (long long )orders[i][1]);
        }


        //买和卖都不为空
        //检查买的最大值，大于卖的最小值
        while(!HeapEmpty(sellHeap) && !HeapEmpty(buyHeap) && HeapGetTop(buyHeap)  >= HeapGetTop(sellHeap) )
        {
            int BuyNum  = buyHeap->num[1];
            int SellNum = sellHeap->num[1];

            if(BuyNum ==  SellNum)
            {
                //删掉卖的订单
                maxHeap = false;
                HeapDelete(sellHeap);

                //删掉买的订单
                maxHeap = true;
                HeapDelete(buyHeap);
            }
            else if(BuyNum > SellNum)
            {
                //删掉卖的订单
                maxHeap = false;
                HeapDelete(sellHeap);

                //买的订单放回去
                buyHeap->num[1] -= SellNum;
            }
            else
            {
                //卖的订单放回去
                sellHeap->num[1] -= BuyNum;

                 //删掉买的订单
                maxHeap = true;
                HeapDelete(buyHeap);
            }
        }
    }

    long long count = 0;
    while(!HeapEmpty(sellHeap))
    {
        count =  (count + sellHeap->num[1])%1000000007;
        HeapDelete(sellHeap);
    }

    while(!HeapEmpty(buyHeap))
    {
        count =  (count + buyHeap->num[1])%1000000007;
        HeapDelete(buyHeap);
    }

    return count%1000000007;
}


作者：小迅
链接：https://leetcode.cn/problems/number-of-orders-in-the-backlog/solutions/2041265/you-xian-dui-lie-zhu-shi-chao-ji-xiang-x-ln8c/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

迅~
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode 155. 最小栈 刷题记录
zy1994384的博客
12-18 86
leetcode刷题记录，算法时间复杂度纠错
LeetCode：优先队列
sfklyqh的博客
01-14 268
179：给定一组非负整数 nums，重新排列每个数的顺序（每个数不可拆分）使之组成一个最大的整数。 class Solution { public String largestNumber(int[] nums) { PriorityQueue<String> queue = new PriorityQueue<>((x,y)-> (y+x).compareTo(x+y)); for(int num:nums){
Leetcode 优先队列详解
若明天不见
03-25 703
本文为优先队列详解及相关题型的解答思路。在优先队列中，元素被赋予优先级，当访问队列元素时，具有最高优先级的元素最先删除。根据数组元素从大到小进行排序本文。解题思路通常为优先队列/最大堆，依次入队排序后取队头的第K大的元素。
leetcode题型—优先级队列(topK问题)
m0_58006481的博客
03-06 1545
leetcode—topK问题：求前k个最大/最小**，求小用大堆，求大用小堆
优先队列经典例题leetcode思路代码详解
最新发布
xiaoliii0401的博客
11-30 614
对优先队列感兴趣的朋友可以去看我上一篇文章。
LeetCode 每日一题 912. 排序数组 C++描述
01-06
  这是LeetCode在2020.03.31的每日一题，题目难度为中等，打开题目之后发现要求很简单，就是一个排序，不过是中等难度，原本以为会在时间复杂度上卡一下，结果也没有卡，这里直接使用C++ STL中的sort()进行一个快...
leetcode每日一题总结.zip
03-24
这个“leetcode每日一题总结.zip”压缩包文件显然包含了一个作者在准备2020年秋季招聘（秋招）时对LeetCode上每日一题的解答和总结。通过这样的练习，作者最终成功签约华为，一家在全球范围内知名的科技公司，这充分...
leetcode第四题-LeetCode.VIP:LeetCode.VIP（蜘蛛问题信息）
07-01
leetcode 第四题力扣VIP 介绍与特点 这是一个关于LeetCode算法问题信息的简单shell工具。 此工具支持 linux 和 Mac OX。...第一列是公司名称。...另一列是公司的问题问题ID。...第一列是问题 ..../LeetCode.VIP/install...LeetCode.
leetcode每日一题在哪-LeetCode-Solutions:我的Leetcode.com解决方案和有用的代码
06-30
每日一题在哪编码_挑战 这是我每天回答 Leetcode 问题的地方。 下面我将为我的每个答案写一个快速解释。 这个 repo 将作为一个地方来跟踪我的问题解决能力以及我的算法交流工作。 ### 2016 年 4 月 11 日星期一 19:...
coolcao#ccsite#【LeetCode每日一题】33.搜索旋转排序数组1
07-25
3. nums 中的每个值都 独一无二 4. nums 肯定会在某个点上旋转 1. 先找到升序区间 2. 如果元素在升序区间内，直接在升序区间对其进行二分查找
[LeetCode]-队列&优先队列/堆
Pacifica_的博客
11-14 354
记录 LeetCode 刷题时遇到的 队列 以及 优先队列相关题目
浅析uthash系列之二：宏函数
JT_Notes的博客
08-01 2128
uthash版本 :2.0.2 作者：jafon.tian 转载请注明出处 简要说明 uthash是采用宏函数来完成hash表功能。总体上可以分为两大类： 1. 对外的API宏函数 2. 内部功能性宏函数 对外的API宏函数 uthash提供了两大类对外API宏函数： 1. 快捷宏函数。快捷宏可以操作key数据类型是整数，指针或字符串的hash表（需要将UT_hash...
哈希表添加（C语言（哈希表（icoding
Bello9的博客
07-09 4886
题目 哈希表添加 哈希表（Hash Table，也叫散列表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做哈希函数，存放记录的数组称做哈希表。哈希表相关定义如下： typedef enum{ HASH_OK, HASH_ERROR, HASH_ADDED, HASH_REPLACED_VALUE, HASH_ALREADY_ADDED,
详述HashSet中add方法
x_j_k_jysg的博客
08-11 5279
一、HashSet中对象的创建 在分析HashSet的add方法的底层代码之前我们先要理解HashSet集合中的对象是如何创建的。 先创建一个JavaWeb工程，引入hashset的包，创建含有HashSet类的方法，然后就可以进入HashSet的底层代码： package hashset; import java.util.HashSet; public class Test { ...
哈希表添加（c语言）
weixin_45454859的博客
06-14 3903
哈希表（Hash Table，也叫散列表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做哈希函数，存放记录的数组称做哈希表。哈希表相关定义如下： typedef enum{ HASH_OK, HASH_ERROR, HASH_ADDED, HASH_REPLACED_VALUE, HASH_ALREADY_ADDED, HASH_D
HASH排序
adddais的博客
03-21 4485
HASH排序原理： 将Value值作为下标，存放在一个conut数组里面。以count数组对应下标的值为计重复次数。遍历count数组。对有值的进行打印下标。完成排序。整体的时间复杂度取决于数组最大数字。 代码如下： int a[9] = {123,122,345,678,123,568,122,122,122}; int count[1000] = {}; for (int...
简单好用的hash表-----uthash
热门推荐
devilcash的专栏
02-03 2万+
在软件开发中，不可不免的会使用到hash表，hash表的优点这里就不说了，以下介绍一个hash表的C实现， uthash是用宏实现的，使用的时候非常方便，只用包含uthash.h即可。 Uthash的三个数据结构： 1. typedef struct UT_hash_bucket {    struct UT_hash_handle *hh_head;    unsigned cou
1696 跳跃游戏 VI
weixin_44171872的博客
12-20 316
题目描述： 给你一个下标从 0 开始的整数数组 nums 和一个整数 k 。 一开始你在下标 0 处。每一步，你最多可以往前跳 k 步，但你不能跳出数组的边界。也就是说，你可以从下标 i 跳到 [i + 1， min(n - 1, i + k)] 包含 两个端点的任意位置。 你的目标是到达数组最后一个位置（下标为 n - 1 ），你的 得分 为经过的所有数字之和。 请你返回你能得到的 最大得分 。 示例 1： 输入：nums = [1,-1,-2,4,-7,3], k = 2 输出：7 解释：你可以选择子序
"LeetCode每日一题高频面试算法题目1：队列实现栈
eue.isEmpty()){  return null;  }  while(queue.size() > 1){  help.add(queue.poll());  } ... LeetCode每日一题高频面试算法题目1中的队列实现栈，为算法学习者提供了一个很好的训练机会。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值