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

已于 2024-10-13 21:21:12 修改
阅读量563 收藏 16
点赞数 21
分类专栏： 手撕力扣题 Java习题算法 数据结构与算法 —— Java实现 文章标签： java 算法 数据结构
于 2024-10-13 21:20:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73983707/article/details/142828929
版权

目录

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);
 */

L_cl
关注
专栏目录
算法、数据结构和编程面试示例 - Java - 下载.zip
09-15
在当今的IT行业中，算法、数据结构以及编程能力是衡量一个程序员专业水平的重要标准，特别是在求职面试中，这些技能的掌握程度往往直接影响到面试的成功与否。本资源包“算法、数据结构和编程面试示例 - Java - 下载...
算法和数据结构——左程云.zip
06-17
总之，《算法和数据结构——左程云》这个资源包是全面学习和提升算法与数据结构知识的宝贵资料，无论你是初学者还是经验丰富的开发者，都能从中受益匪浅。通过深入学习和实践，你将能够更好地应对各种编程挑战，提升...
Data-Structure:《数据结构与算法分析》上的代码实现
05-03
《数据结构与算法分析》上的代码实现, 按照该书的章节顺序，主要实现书上给出的例子。 ##已经实现： ###第三章 - 链表 - 栈 - 队列 ###第四章 - 排序二叉树 - 平衡二叉树 - 伸展树（自底向上） - 伸展树（自顶往下）...
神经网络算法与实现 ——基于Java语言 代码实例
12-04
《神经网络算法与实现——基于Java语言 代码实例》是一本深入探讨神经网络编程的书籍，专注于使用Java语言实现各种神经网络模型。本书通过实际的代码示例，为读者提供了理解神经网络工作原理以及如何在Java环境下...
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1445
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
Puppeteer自动化：使用JavaScript定制PDF下载
ip16yun的博客
10-08 917
Puppeteer 是一个强大的Node.js库，提供了对无头Chrome或Chromium的控制，可以用于生成网页快照、抓取数据、自动化测试等任务。其中，生成PDF文件是一个常见的需求，本文将通过使用Puppeteer展示如何自动化生成定制的PDF，并使用代理IP、设置user-agent、cookie等技术来增强自动化过程的灵活性与稳定性。为了更好地理解如何定制Puppeteer生成的PDF文件，我们提供一个生成A4纸张格式的网页PDF的实例。用户可以根据需求自定义输出的PDF格式或内容。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 657
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
JavaSE——认识异常
wx2023_10_15的博客
10-12 943
本文主要是正在学习异常的总结，主要讲了异常的概念、体系结构、分类、处理以及捕获，还有自定义异常类
springboot 用request.setAttribute 传值到控制层
qq56477643的博客
10-09 606
【代码】springboot 用request.setAttribute 传值到控制层。
【网络编程】掌握Java网络编程：深入理解Socket通信与实战技巧
Dylaniou的博客
10-11 1044
Java的网络Socket编程为开发者提供了强大的工具来构建网络通信应用，从简单的客户端-服务器模型到复杂的分布式系统。Java的网络Socket编程为开发者提供了强大的工具来构建网络通信应用，从简单的客户端-服务器模型到复杂的分布式系统。希望本文能帮助您掌握Java网络编程的核心技术，并在实际项目中灵活运用。如果您有任何疑问或想要分享经验，请在评论区留下您宝贵的意见！🚀🌐🔌。
Unsafe 详解
qq_73210658的博客
10-10 2472
学习JUC的过程中发现有一个类很神奇，今天我们就来一起学习一下Unsafe类。
Java基础-基础知识体系小结 Q/A
令狐_JackieHao的博客
10-10 1298
Java基础知识的一些梳理
C++ 的存储类型与新的 thread_local
最新发布
oRbIt 的专栏
10-14 511
存储周期只是一个概念，是程序语义范畴内的东西，但不是语法的范畴。存储类型说明符也被称为存储类型，它们是变量声明语法中类型说明符的一部分，它们和变量名的范围一起控制变量的两个独立属性，即存储周期和链接属性。
JavaScript前端开发技术
Chujun123528的博客
10-12 981
JavaScript前端开发是一个充满挑战和机遇的领域。随着技术的不断进步和用户需求的变化，前端开发者需要不断学习新知识、掌握新技能，以应对日益复杂和多样化的开发需求。同时，注重性能优化和安全实践也是前端开发不可或缺的一部分。通过不断探索和创新，我们可以为用户创造更加优质、高效和安全的Web体验。在JavaScript前端开发的学习过程中，建议从基础语法入手，逐步掌握DOM操作、事件处理、Ajax通信等核心技能。同时，关注最新的前端框架和库的发展动态，尝试将它们应用到实际项目中。
SpringBoot 集成 Redis 总结
SOS5418818845的博客
10-11 494
Redis 是一个开源的内存数据结构存储系统，它可以用作数据库、缓存和消息中间件。Redis 以其高效的性能、丰富的数据结构和简单的 API 而受到广泛关注。它将数据存储在内存中，并可以通过持久化机制将数据保存到硬盘上，以防止数据丢失。
springcloud微服务基本概念
牧风人的博客
10-11 889
微服务架构的4个核心问题 ​ 1.服务很多，客户端怎么访问 ​ 2.这么多的服务，服务之间怎么通信 ​ 3.这么多的服务，怎么统一治理 ​ 4.服务挂了怎么办 解决方案： SpringCloud 生态 1.Spring Cloud NetFlix 一站式解决方案！ 但停更了 api网关，zuul组件 Feign---...
Linux线程（十二）线程互斥锁-自旋锁与读写锁详解
Dola的博客
10-10 932
自旋锁与互斥锁很相似，从本质上说也是一把锁，在访问共享资源之前对自旋锁进行上锁，在访问完成后释放自旋锁（解锁）；事实上，从实现方式上来说，互斥锁是基于自旋锁来实现的，所以自旋锁相较于互斥锁更加底层。如果在获取自旋锁时，自旋锁处于未锁定状态，那么将立即获得锁（对自旋锁上锁）；如果在获取自旋锁时，自旋锁已经处于锁定状态了，那么获取锁操作将会在原地“自旋”，直到该自旋锁的持有者释放了锁。由此介绍可知，自旋锁与互斥锁相似，但是互斥锁在无法获取到锁时会让线程陷入阻塞等待状态；
在Windows 10上安装Java 17的步骤如下
S.Ybling
10-09 313
至此，Java 17已经成功安装并配置在Windows 10系统中。安装完成后，需要配置环境变量，以便在命令行中可以直接使用。
JavaScript的内置对象有哪些？
2301_81449444的博客
10-08 1360
sort() 是对数字数组的元素进行排序，返回值为修改后的数组，根据参数的不同来判断是进行升序排序还是降序排序，默认无参数时，排序顺序是在将元素转换为字符串，然后比较它们的 UTF-16 代码单元值序列进行排序的，如果参数为“function(a,b){ return a-b;如果传入了参数，那么则按照参数来创建时间对象。其中new Array() 在没有参数时，创建的是一个空的数组对象，需要后续添加数组元素，但如果在创建数组时传入了一个参数，则参数代表数组的长度，如果传入了多个参数，则参数为数组元素。
程序员必修：数据结构与算法(Java版)第二版——基石与高效编程
在《数据结构与算法分析(Java版)中文第二版》中，作者强调了在编程生涯早期打下坚实基础的重要性。作为一名程序员，尤其是初学者，离散数学、算法与数据结构、操作系统、计算机体系结构、编译原理等基础知识是必不可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值