数据结构与算法——Java实现 35.求数据流中的第K大元素

news2025/2/26 1:54:45

目录

703. 数据流中的第 K 大元素

思路

题目解析：

数据流：

数据流和数组的区别：

代码实现

小顶堆类

测试类

力扣

我想成为一个强大、坦荡又热血的人，我爱霓虹闪烁，也爱高山流水，更爱我自己

                                                                                                                —— 24.10.13

703. 数据流中的第 K 大元素

设计一个找到数据流中第 k 大元素的类（class）。注意是排序后的第 k 大元素，不是第 k 个不同的元素。

请实现 KthLargest 类：

  • KthLargest(int k, int[] nums) 使用整数 k 和整数流 nums 初始化对象。
  • int add(int val) 将 val 插入数据流 nums 后，返回当前数据流中第 k 大的元素。

示例 1：

输入：
["KthLargest", "add", "add", "add", "add", "add"]
[[3, [4, 5, 8, 2]], [3], [5], [10], [9], [4]]

输出：[null, 4, 5, 5, 8, 8]

解释：

KthLargest kthLargest = new KthLargest(3, [4, 5, 8, 2]);
kthLargest.add(3); // 返回 4
kthLargest.add(5); // 返回 5
kthLargest.add(10); // 返回 5
kthLargest.add(9); // 返回 8
kthLargest.add(4); // 返回 8

示例 2：

输入：
["KthLargest", "add", "add", "add", "add"]
[[4, [7, 7, 7, 7, 8, 3]], [2], [10], [9], [9]]

输出：[null, 7, 7, 7, 8]

解释：

KthLargest kthLargest = new KthLargest(4, [7, 7, 7, 7, 8, 3]);
kthLargest.add(2); // 返回 7
kthLargest.add(10); // 返回 7
kthLargest.add(9); // 返回 7
kthLargest.add(9); // 返回 8

思路

题目解析：

题目要求实现KthLargest类，参数列表要求传入一个整数k，代表要查找的由高到低的顺序排列，add方法，要求传入一个整数，将这个整数加入到原先数组中，按照顺序排列，当数据流有新的元素的时候，重新按升序排序数组，倒数第k个元素就是第k大的数，再从加入元素后并已排序的数组中找到倒数第k个元素，将倒数第k个元素返回

数据流：

在编程中，数据流指的是一系列连续的数据元素在系统中流动和处理的概念，本题中的数据流由整型数组实现

数据流和数组的区别：

数据流的数据是变化的，意味着有可能有更多的元素添加进来，数组是固定的

代码实现

小顶堆类

import java.util.Arrays;

public class MinHeap {
    int[] heapArray;
    int size;

    public MinHeap(int capacity) {
        heapArray = new int[capacity];
    }

    public MinHeap(int[] Array) {
        heapArray = new int[Array.length];
        System.arraycopy(Array, 0, heapArray, 0, Array.length);
        size = Array.length;
        buildHeap();
    }

    private void buildHeap() {
        for (int i = size / 2 - 1; i >= 0; i--) {
            heapifyDown(i);
        }
    }

    public void heapifyDown(int index) {
        int leftChildIndex = 2 * index + 1;
        int rightChildIndex = leftChildIndex + 1;
        int SmallIndex = index;

        if (leftChildIndex < size && heapArray[leftChildIndex] < heapArray[SmallIndex]) {
            SmallIndex = leftChildIndex;
        }

        if (rightChildIndex < size && heapArray[rightChildIndex] < heapArray[SmallIndex]) {
            SmallIndex = rightChildIndex;
        }

        if (SmallIndex!= index) {
            swap(index, SmallIndex);
            heapifyDown(SmallIndex);
        }
    }

    public void swap(int i, int j) {
        int temp = heapArray[i];
        heapArray[i] = heapArray[j];
        heapArray[j] = temp;
    }

    public int peek() {
        if (size == 0) {
            return -1;
        }
        return heapArray[0];
    }

    public int poll() {
        if (size == 0) {
            return -1;
        }
        int maxValue = heapArray[0];
        heapArray[0] = heapArray[size - 1];
        size--;
        heapifyDown(0);
        return maxValue;
    }

    public int poll(int index) {
        if (size == 0 || index >= size) {
            return -1;
        }
        int removedValue = heapArray[index];
        heapArray[index] = heapArray[size - 1];
        size--;
        heapifyDown(index);
        return removedValue;
    }

    public void replace(int newValue) {
        if (size == 0) {
            return;
        }
        heapArray[0] = newValue;
        heapifyDown(0);
    }

    public boolean offer(int value) {
        if (size == heapArray.length) {
            return false;
        }
        heapArray[size] = value;
        heapifyUp(size);
        size++;
        return true;
    }

    private void heapifyUp(int index) {
        int parentIndex = (index - 1) / 2;
        while (index > 0 && heapArray[index] < heapArray[parentIndex]) {
            swap(index, parentIndex);
            index = parentIndex;
            parentIndex = (index - 1) / 2;
        }
    }

    public boolean isFull(){
        return size == heapArray.length;
    }


    public static void main(String[] args) {
        int[] Arr = {1, 2, 3, 4, 5, 6, 7};
        MinHeap maxHeap = new MinHeap(Arr);
        System.out.println(Arrays.toString(maxHeap.heapArray));
        // [7, 5, 6, 4, 2, 1, 3]

        maxHeap.replace(5);
        System.out.println(Arrays.toString(maxHeap.heapArray));
        // [6, 5, 5, 4, 2, 1, 3]

        maxHeap.poll(2);
        System.out.println(Arrays.toString(maxHeap.heapArray));
        // [6, 5, 3, 4, 2, 1, 3]

        System.out.println(maxHeap.peek());
        // 6

        maxHeap.poll();
        System.out.println(Arrays.toString(maxHeap.heapArray));
        // [5, 4, 3, 1, 2, 1, 3]

        System.out.println(maxHeap.offer(5));
        // true
        System.out.println(Arrays.toString(maxHeap.heapArray));
        // [5, 4, 5, 1, 2, 3, 3]

        maxHeap.poll();
        System.out.println(Arrays.toString(maxHeap.heapArray));
        // [5, 4, 3, 1, 2, 3, 3]

        maxHeap.offer(9);
        System.out.println(Arrays.toString(maxHeap.heapArray));
        // [9, 4, 5, 1, 2, 3, 3]
    }
}

测试类

public class LeetCode703MaxInDataStream {
    private MinHeap heap;

    // 在数组之中寻找第k大的元素
    public LeetCode703MaxInDataStream(int k,int[] nums) {
        heap = new MinHeap(k);
        for (int num : nums) {
            add(num);
        }
    }

    // 不断调用，模拟数据流中新传来的元素
    public int add(int val){
        if (!heap.isFull()){
            heap.offer(val);
        }else if(val > heap.peek()){
            heap.replace(val);
        }
        return heap.peek();
    }

    public static void main(String[] args) {
        LeetCode703MaxInDataStream test = new LeetCode703MaxInDataStream(3,new int[]{5,7,9,6,4});

        // 小顶堆，4 5 8 留下最大的k个就行
        System.out.println(test.add(11));
        System.out.println(test.add(7));
        System.out.println(test.add(9));
        System.out.println(test.add(6));
        System.out.println(test.add(4));
    }
}

力扣

import java.util.Arrays;

public class MinHeap {
    int[] heapArray;
    int size;

    public MinHeap(int capacity) {
        heapArray = new int[capacity];
    }

    public MinHeap(int[] Array) {
        heapArray = new int[Array.length];
        System.arraycopy(Array, 0, heapArray, 0, Array.length);
        size = Array.length;
        buildHeap();
    }

    private void buildHeap() {
        for (int i = size / 2 - 1; i >= 0; i--) {
            heapifyDown(i);
        }
    }

    public void heapifyDown(int index) {
        int leftChildIndex = 2 * index + 1;
        int rightChildIndex = leftChildIndex + 1;
        int SmallIndex = index;

        if (leftChildIndex < size && heapArray[leftChildIndex] < heapArray[SmallIndex]) {
            SmallIndex = leftChildIndex;
        }

        if (rightChildIndex < size && heapArray[rightChildIndex] < heapArray[SmallIndex]) {
            SmallIndex = rightChildIndex;
        }

        if (SmallIndex!= index) {
            swap(index, SmallIndex);
            heapifyDown(SmallIndex);
        }
    }

    public void swap(int i, int j) {
        int temp = heapArray[i];
        heapArray[i] = heapArray[j];
        heapArray[j] = temp;
    }

    public int peek() {
        if (size == 0) {
            return -1;
        }
        return heapArray[0];
    }

    public int poll() {
        if (size == 0) {
            return -1;
        }
        int maxValue = heapArray[0];
        heapArray[0] = heapArray[size - 1];
        size--;
        heapifyDown(0);
        return maxValue;
    }

    public int poll(int index) {
        if (size == 0 || index >= size) {
            return -1;
        }
        int removedValue = heapArray[index];
        heapArray[index] = heapArray[size - 1];
        size--;
        heapifyDown(index);
        return removedValue;
    }

    public void replace(int newValue) {
        if (size == 0) {
            return;
        }
        heapArray[0] = newValue;
        heapifyDown(0);
    }

    public boolean offer(int value) {
        if (size == heapArray.length) {
            return false;
        }
        heapArray[size] = value;
        heapifyUp(size);
        size++;
        return true;
    }

    private void heapifyUp(int index) {
        int parentIndex = (index - 1) / 2;
        while (index > 0 && heapArray[index] < heapArray[parentIndex]) {
            swap(index, parentIndex);
            index = parentIndex;
            parentIndex = (index - 1) / 2;
        }
    }

    public boolean isFull(){
        return size == heapArray.length;
    }


    public static void main(String[] args) {
        int[] Arr = {1, 2, 3, 4, 5, 6, 7};
        MinHeap maxHeap = new MinHeap(Arr);
        System.out.println(Arrays.toString(maxHeap.heapArray));
        // [7, 5, 6, 4, 2, 1, 3]

        maxHeap.replace(5);
        System.out.println(Arrays.toString(maxHeap.heapArray));
        // [6, 5, 5, 4, 2, 1, 3]

        maxHeap.poll(2);
        System.out.println(Arrays.toString(maxHeap.heapArray));
        // [6, 5, 3, 4, 2, 1, 3]

        System.out.println(maxHeap.peek());
        // 6

        maxHeap.poll();
        System.out.println(Arrays.toString(maxHeap.heapArray));
        // [5, 4, 3, 1, 2, 1, 3]

        System.out.println(maxHeap.offer(5));
        // true
        System.out.println(Arrays.toString(maxHeap.heapArray));
        // [5, 4, 5, 1, 2, 3, 3]

        maxHeap.poll();
        System.out.println(Arrays.toString(maxHeap.heapArray));
        // [5, 4, 3, 1, 2, 3, 3]

        maxHeap.offer(9);
        System.out.println(Arrays.toString(maxHeap.heapArray));
        // [9, 4, 5, 1, 2, 3, 3]
    }
}

class KthLargest {
    private MinHeap heap;

    // 在数组之中寻找第k大的元素
    public KthLargest(int k,int[] nums) {
        heap = new MinHeap(k);
        for (int num : nums) {
            add(num);
        }
    }

    // 不断调用，模拟数据流中新传来的元素
    public int add(int val){
        if (!heap.isFull()){
            heap.offer(val);
        }else if(val > heap.peek()){
            heap.replace(val);
        }
        return heap.peek();
    }
}

/**
 * Your KthLargest object will be instantiated and called as such:
 * KthLargest obj = new KthLargest(k, nums);
 * int param_1 = obj.add(val);
 */

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2213189.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

视频的编解码格式

视频的编解码格式

文章目录 视频的编解码格式概念术语视频处理流程视频封装格式视频编码格式视频编解码器&#xff0c;视频容器和视频文件格式之间的区别补充视频码率 参考资料 视频的编解码格式 概念术语 两大组织主导视频压缩的组织及其联合(joint)组织 ITU-T(VCEG) ITU-T的中文名称是国际电信…
阅读更多...
【wpf】05 几种容器动态创建控件的对比

【wpf】05 几种容器动态创建控件的对比

今天利用一点时间&#xff0c;对wpf中在常用容器中动态创建控件的方法进行了学习和测试&#xff0c;本篇文章用来记录这个过程及一些心得。 1 容器说明 用于对比的wpf常用容器类包括如下七种&#xff1a; StackPanelGridScrollViewerWrapPanelCanvasUniformGridDockPanel 以…
阅读更多...
Vue实现动态表单

Vue实现动态表单

使用 Vue 实现动态表单 在前端开发中&#xff0c;我们经常遇到根据用户输入动态生成不同表单项的需求。这类动态表单不仅提升了用户体验&#xff0c;还可以让复杂的交互流程变得简洁而高效。本文将详细讲解如何使用 Vue 3 的响应式特性&#xff0c;逐步构建一个递归动态表单。…
阅读更多...
服务器虚拟化的好处有哪些

服务器虚拟化的好处有哪些

1.什么是服务器虚拟化&#xff1f; 在计算服务中&#xff0c;有7种虚拟化包括硬件虚拟化&#xff08;即服务器虚拟化&#xff09;、软件虚拟化、内存虚拟化、存储虚拟化、数据虚拟化、网络虚拟化和桌面虚拟化。 其中&#xff0c;服务器虚拟化的初衷是让Windows和Linux操作系统…
阅读更多...
【环境搭建】更换电脑后的开发环境怎么重建

【环境搭建】更换电脑后的开发环境怎么重建

目录 &#x1f378;前言 &#x1f37b;一、系统配置检查 &#x1f37a;二、开发环境搭建 &#x1f379;三、章末 &#x1f378;前言 小伙伴们大家好&#xff0c;这次文章跟技术没有关联&#xff0c;因为最近刚更换了装备&#xff0c;开发环境啥的残缺不全&#xff0c;也不能…
阅读更多...
多倍体重测序-经典分析思路

多倍体重测序-经典分析思路

你知道吗&#xff1f;甘蔗不仅是全球糖分的主要来源&#xff0c;而且它还隐藏着许多未被发掘的秘密。今天&#xff0c;我们就来聊聊科学家们是如何通过全基因组测序技术解开甘蔗品种改良之谜的&#xff01; 广东省科学院南繁种业研究所在《The Plant Journal》杂志上发表题为“…
阅读更多...
vue3项目在vue平台下添加nvue文件会报[plugin:vite:nvue-css]

vue3项目在vue平台下添加nvue文件会报[plugin:vite:nvue-css]

项目运行是会报大量的[plugin:vite:nvue-css]作警告 解决办法&#xff1a;在app.vue引入公共css文件外添加#ifndef APP-PLUS-NVUE条件 // #ifndef APP-PLUS-NVUE import "uview-plus/index.scss"; /*每个页面公共css */ import "colorui/main.css"; //#en…
阅读更多...
微信小程序考试系统(lw+演示+源码+运行）

微信小程序考试系统(lw+演示+源码+运行）

摘要 随着信息技术在管理上越来越深入而广泛的应用&#xff0c;管理信息系统的实施在技术上已逐步成熟。本文介绍了微信小程序考试系统的开发全过程。通过分析微信小程序考试系统管理的不足&#xff0c;创建了一个计算机管理微信小程序考试系统的方案。文章介绍了微信小程序考…
阅读更多...
Leetcode 1168. 水资源分配优化

Leetcode 1168. 水资源分配优化

1.题目基本信息 1.1.题目描述 村里面一共有 n 栋房子。我们希望通过建造水井和铺设管道来为所有房子供水。 对于每个房子 i&#xff0c;我们有两种可选的供水方案&#xff1a;一种是直接在房子内建造水井&#xff0c;成本为 wells[i – 1] &#xff08;注意 -1 &#xff0c;…
阅读更多...
双十一买什么东西比较好？2024双11好物攻略诚意分享

双十一买什么东西比较好？2024双11好物攻略诚意分享

双十一活动已经准备要开始了&#xff0c;很多人摩拳擦掌准备入手划算好物&#xff0c;但是有的人也比较迷茫&#xff0c;双十一买什么东西比较好&#xff1f;为了帮助大家在这场购物狂欢中理性消费&#xff0c;提升购物体验&#xff0c;我们精心整理了一份2024双11好物攻略诚意…
阅读更多...
扭亏年只是开始，赛力斯的成长性仍在继续

扭亏年只是开始，赛力斯的成长性仍在继续

赛力斯的三季度业绩报告发出之后&#xff0c;不少股民在评论区如释重负&#xff1a; 大雪压我两三年&#xff0c;我笑大雪轻如棉。 业绩预告显示&#xff0c;赛力斯2024年前三季度营业收入同比大增518%到559%&#xff0c;达1030.0亿元到1100.0亿元&#xff1b;同时净利润连续…
阅读更多...
2018年计算机网络408真题解析

2018年计算机网络408真题解析

第一题&#xff1a; 解析&#xff1a;TCP/IP体系结构应用层常用协议及其相应的运输层协议 TCP协议是面向连接可靠数据传输服务&#xff0c;UDP无连接不可靠的数据传输服务&#xff0c;IP无连接不可靠的数据连接服务。 FTP协议&#xff0c;SMTP协议和HTTP协议使用TCP协议提供的面…
阅读更多...
防爆手机能有多轻薄？AORO A29小身躯在石油化工有大作为！

防爆手机能有多轻薄？AORO A29小身躯在石油化工有大作为！

防爆手机能有多轻薄&#xff1f;AORO A29防爆手机机身尺寸为177.4*81.5*12.75mm&#xff0c;重量仅为334.5g&#xff0c;其轻薄的设计在一众“砖头”工业防爆手机中脱颖而出。 轻薄是不是意味着功能削减&#xff1f;AORO A29防爆手机在保持轻薄体态的同时&#xff0c;集成了九…
阅读更多...
数据结构（七大排序）

数据结构（七大排序）

前言 前话&#xff1a;排序在我们日常中很常见&#xff0c;但在不同的场合我们需要选择不同的排序&#xff0c;因为每个排序都有不同的使用场景&#xff0c;不同的时间复杂度和空间复杂度&#xff1b;常见的排序分为七种&#xff0c; 插入排序、选择排序、交换排序和归并排序&…
阅读更多...
2024 年 Mac 下这些生产力工具，好用到哭

2024 年 Mac 下这些生产力工具，好用到哭

每段关系最终都会结束 即使不是因为别的原因 也会因为死亡 我只知道 你不对她说出来 她就永远不知道 你的心意 她那天离开的时候 才知道一个道理 有时候 保护一样重要的东西的方式 不是守在她旁边 而是离开她 离得远远的远到看起来谁也 不在乎谁一样 今天呢&#x…
阅读更多...
FPGA上板调试方式总结----VIO/ILA

FPGA上板调试方式总结----VIO/ILA

在Vivado中&#xff0c;VIO&#xff08;Virtual Input/Output&#xff09;是一种用于调试和测试FPGA设计的IP核&#xff0c;它允许设计者通过JTAG接口实时读取和写入FPGA内部的寄存器&#xff0c;从而检查设计的运行状态并修改其行为。VIO IP核提供了一个简单易用的接口&#x…
阅读更多...
Redis总结（官方文档解读）

Redis总结（官方文档解读）

定义 Redis是一个开源的&#xff0c;基于内存的数据结构存储系统&#xff0c;可以用作数据库、缓存和消息中间件。 特征 高性能 支持丰富的数据类型 丰富的操作类型&#xff0c;操作是原子性的 支持周期性持久化 支持分布式 开源免费&#xff0c;社区活跃 数据类型 数据…
阅读更多...
图片加水印怎么弄？四款软件供你选择！

图片加水印怎么弄？四款软件供你选择！

在这个信息爆炸的时代&#xff0c;每一张图片都可能成为你创意与努力的结晶。然而&#xff0c;网络上的复制粘贴如此轻易&#xff0c;如何有效保护自己的原创作品&#xff0c;防止未经授权的盗用&#xff0c;成为了每位创作者必须面对的问题。别担心&#xff0c;今天我们就来揭…
阅读更多...
[Linux系统编程]线程概念，三级映射，线程操作函数

[Linux系统编程]线程概念，三级映射，线程操作函数

一.线程概念 线程概念&#xff1a; 进程&#xff1a;有独立的 进程地址空间。有独立的pcb。 进程是分配资源的最小单位。 线程&#xff1a;没有独立的进程地址空间。有独立的pcb。 进程是cup执行的最小单位。 线程有线程id和线程号&#xff0c;线程id是用于进程内部标识线程…
阅读更多...
2024年10款超好用的图纸加密软件推荐|企业常用图纸加密软件分享

2024年10款超好用的图纸加密软件推荐|企业常用图纸加密软件分享

在数字化时代&#xff0c;图纸作为企业的关键技术资产&#xff0c;承载着大量敏感信息&#xff0c;泄露这些图纸不仅可能导致重大经济损失&#xff0c;还可能危及企业的市场竞争力。因此&#xff0c;选择一款合适的图纸加密软件&#xff0c;对企业而言至关重要。为了帮助企业保…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023