当需要对大量数据进行排序操作时，怎样优化内存使用和性能？

news2025/4/6 5:17:34

文章目录

  • 一、选择合适的排序算法
    • 1. 快速排序
    • 2. 归并排序
    • 3. 堆排序
  • 二、数据结构优化
    • 1. 使用索引
    • 2. 压缩数据
    • 3. 分块排序
  • 三、外部排序
    • 1. 多路归并排序
  • 四、利用多核和并行计算
    • 1. 多线程排序
    • 2. 使用并行流
  • 五、性能调优技巧
    • 1. 避免不必要的内存复制
    • 2. 缓存友好性
    • 3. 基准测试和性能分析

美丽的分割线

PostgreSQL


在处理大量数据的排序操作时，优化内存使用和性能是至关重要的。这不仅可以提高程序的运行效率，还可以避免因内存不足导致的崩溃或错误。下面我们将详细探讨一些优化的方法，并提供相应的示例代码来帮助理解。

美丽的分割线

一、选择合适的排序算法

不同的排序算法在时间和空间复杂度上有所不同，因此根据数据的特点选择合适的排序算法是优化的第一步。

1. 快速排序

快速排序是一种分治的排序算法，平均情况下它的时间复杂度为 O ( n log ⁡ n ) O(n \log n) O(nlogn)，空间复杂度为 O ( log ⁡ n ) O(\log n) O(logn) 到 O ( n ) O(n) O(n)。在大多数情况下，快速排序的性能都非常出色，特别是对于随机分布的数据。

public class QuickSort {

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

    public static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = (low - 1);

        for (int j = low; j <= high - 1; j++) {
            if (arr[j] <= pivot) {
                i++;
                swap(arr, i, j);
            }
        }
        swap(arr, i + 1, high);
        return (i + 1);
    }

    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pi = partition(arr, low, high);

            quickSort(arr, low, pi - 1);
            quickSort(arr, pi + 1, high);
        }
    }

    public static void main(String[] args) {
        int[] arr = {10, 7, 8, 9, 1, 5};
        int n = arr.length;

        System.out.println("排序前的数组为：");
        for (int num : arr) {
            System.out.print(num + " ");
        }

        quickSort(arr, 0, n - 1);

        System.out.println("\n 排序后的数组为：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

2. 归并排序

归并排序的时间复杂度始终为 O ( n log ⁡ n ) O(n \log n) O(nlogn)，空间复杂度为 O ( n ) O(n) O(n)。它在处理数据量较大且对稳定性有要求的情况下表现良好。

public class MergeSort {

    public static void merge(int[] arr, int l, int m, int r) {
        int n1 = m - l + 1;
        int n2 = r - m;

        int[] L = new int[n1];
        int[] R = new int[n2];

        for (int i = 0; i < n1; i++) {
            L[i] = arr[l + i];
        }

        for (int j = 0; j < n2; j++) {
            R[j] = arr[m + 1 + j];
        }

        int i = 0, j = 0, k = l;

        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                arr[k++] = L[i++];
            } else {
                arr[k++] = R[j++];
            }
        }

        while (i < n1) {
            arr[k++] = L[i++];
        }

        while (j < n2) {
            arr[k++] = R[j++];
        }
    }

    public static void mergeSort(int[] arr, int l, int r) {
        if (l < r) {
            int m = l + (r - l) / 2;

            mergeSort(arr, l, m);
            mergeSort(arr, m + 1, r);

            merge(arr, l, m, r);
        }
    }

    public static void main(String[] args) {
        int[] arr = {12, 11, 13, 5, 6};

        System.out.println("排序前的数组为：");
        for (int num : arr) {
            System.out.print(num + " ");
        }

        mergeSort(arr, 0, arr.length - 1);

        System.out.println("\n 排序后的数组为：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

3. 堆排序

堆排序的时间复杂度为 O ( n log ⁡ n ) O(n \log n) O(nlogn)，空间复杂度为 O ( 1 ) O(1) O(1)。它不需要额外的存储空间，但相对来说实现较为复杂。

public class HeapSort {

    public static void heapify(int[] arr, int n, int i) {
        int largest = i;
        int l = 2 * i + 1;
        int r = 2 * i + 2;

        if (l < n && arr[i] < arr[l]) {
            largest = l;
        }

        if (r < n && arr[largest] < arr[r]) {
            largest = r;
        }

        if (largest!= i) {
            int swap = arr[i];
            arr[i] = arr[largest];
            arr[largest] = swap;

            heapify(arr, n, largest);
        }
    }

    public static void heapSort(int[] arr) {
        int n = arr.length;

        for (int i = n / 2 - 1; i >= 0; i--) {
            heapify(arr, n, i);
        }

        for (int i = n - 1; i >= 0; i--) {
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;

            heapify(arr, i, 0);
        }
    }

    public static void main(String[] args) {
        int[] arr = {12, 11, 13, 5, 6};

        System.out.println("排序前的数组为：");
        for (int num : arr) {
            System.out.print(num + " ");
        }

        heapSort(arr);

        System.out.println("\n 排序后的数组为：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

美丽的分割线

二、数据结构优化

除了选择合适的排序算法，还可以通过优化数据结构来提高排序的性能和内存使用。

1. 使用索引

如果数据本身具有一定的特征，例如按照某个特定字段有序存储，可以通过建立索引来加速排序过程。在数据库中，索引常用于快速定位和排序数据。

2. 压缩数据

对于某些数据，如果其中存在大量重复值或者可以进行有效的压缩编码，通过压缩数据可以减少内存占用。

3. 分块排序

将大量数据分成较小的块进行排序，然后再对块进行合并。这样可以在有限的内存中逐步处理数据，避免一次性加载和处理全部数据。

public class BlockSort {

    public static void sortBlock(int[] arr, int blockSize) {
        int numBlocks = (arr.length + blockSize - 1) / blockSize;

        for (int i = 0; i < numBlocks; i++) {
            int start = i * blockSize;
            int end = Math.min(start + blockSize, arr.length);

            Arrays.sort(arr, start, end);
        }

        int[] sorted = new int[arr.length];
        int index = 0;

        for (int i = 0; i < numBlocks - 1; i++) {
            int[] block = Arrays.copyOfRange(arr, i * blockSize, (i + 1) * blockSize);

            for (int num : block) {
                sorted[index++] = num;
            }
        }

        int[] lastBlock = Arrays.copyOfRange(arr, (numBlocks - 1) * blockSize, arr.length);

        for (int num : lastBlock) {
            sorted[index++] = num;
        }

        System.arraycopy(sorted, 0, arr, 0, arr.length);
    }

    public static void main(String[] args) {
        int[] arr = {9, 1, 5, 3, 7, 2, 8, 6, 4};
        int blockSize = 3;

        System.out.println("排序前的数组为：");
        for (int num : arr) {
            System.out.print(num + " ");
        }

        sortBlock(arr, blockSize);

        System.out.println("\n 排序后的数组为：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

美丽的分割线

三、外部排序

当数据量过大，无法一次性加载到内存中时，就需要使用外部排序算法。外部排序通常基于磁盘存储，通过多次读写数据来完成排序过程。

1. 多路归并排序

将数据分成多个子文件进行排序，然后逐步将这些已排序的子文件合并成最终的排序结果。

public class ExternalSort {

    public static void mergeFiles(String[] fileNames) {
        // 实现多路归并的逻辑
    }

    public static void createSubFiles(int[] arr, int numSubFiles) {
        // 将数据分成子文件
    }

    public static void externalSort(int[] arr) {
        createSubFiles(arr, 5); 
        String[] fileNames = new String[5]; 
        // 为每个子文件命名

        mergeFiles(fileNames);
    }

    public static void main(String[] args) {
        int[] arr = {9, 1, 5, 3, 7, 2, 8, 6, 4};

        externalSort(arr);
    }
}

美丽的分割线

四、利用多核和并行计算

在现代计算机系统中，通常具有多核处理器，可以利用并行计算的能力来加速排序过程。

1. 多线程排序

通过创建多个线程同时对不同的数据部分进行排序，最后合并排序结果。

public class MultiThreadSort {

    private static int[] arr;
    private static int numThreads;

    public static class SortThread extends Thread {
        private int start;
        private int end;

        public SortThread(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        public void run() {
            Arrays.sort(arr, start, end);
        }
    }

    public static void parallelQuickSort(int[] arr, int numThreads) {
        MultiThreadSort.arr = arr;
        MultiThreadSort.numThreads = numThreads;

        int chunkSize = arr.length / numThreads;

        Thread[] threads = new Thread[numThreads];

        for (int i = 0; i < numThreads; i++) {
            int start = i * chunkSize;
            int end = (i == numThreads - 1)? arr.length : (i + 1) * chunkSize;

            threads[i] = new SortThread(start, end);
            threads[i].start();
        }

        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 合并排序结果
    }

    public static void main(String[] args) {
        int[] arr = {9, 1, 5, 3, 7, 2, 8, 6, 4};
        int numThreads = 4;

        parallelQuickSort(arr, numThreads);
    }
}

2. 使用并行流

Java 8 引入的并行流可以方便地实现并行计算。

public class ParallelSortExample {

    public static void main(String[] args) {
        int[] arr = {9, 1, 5, 3, 7, 2, 8, 6, 4};

        Arrays.parallelSort(arr);

        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

美丽的分割线

五、性能调优技巧

除了上述的方法，还有一些通用的性能调优技巧可以应用于排序操作。

1. 避免不必要的内存复制

在数据处理过程中，尽量减少数据的复制操作，以降低内存开销和提高性能。

2. 缓存友好性

合理安排数据的存储和访问方式，以使其更符合 CPU 的缓存机制，提高缓存命中率。

3. 基准测试和性能分析

通过对不同的排序实现进行基准测试和性能分析，找出瓶颈所在，并针对性地进行优化。

总之，在面对大量数据的排序问题时，需要综合考虑以上提到的各种方法和技巧，根据具体的应用场景和数据特点选择最合适的方案。同时，不断地进行实验和优化，以达到最佳的性能和内存使用效果。


美丽的分割线

🎉相关推荐

  • 🍅关注博主🎗️ 带你畅游技术世界，不错过每一次成长机会！
  • 📢学习做技术博主创收
  • 📚领书：PostgreSQL 入门到精通.pdf
  • 📙PostgreSQL 中文手册
  • 📘PostgreSQL 技术专栏

PostgreSQL

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

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

相关文章

Qt（MSVC）下报“语法错误缺少“}““语法错误缺少“常数“ 的解决办法

Qt（MSVC）下报“语法错误缺少“}““语法错误缺少“常数“ 的解决办法

1.现象 目前我在工程中试图使用QHttpServer时&#xff0c;一编译&#xff0c;就报了一堆奇奇怪怪的错误&#xff1a; D:\Qt\httpServer\Qt5.15.2\include\QtHttpServer\qhttpserverrequest.h:75: error: C2143: 语法错误: 缺少“}”(在“(”的前面) D:\Qt\httpServer\Qt5.15.…
阅读更多...
最新扣子(Coze)实战案例：使用图像流做超分，模糊图片秒变清晰，完全免费教程

最新扣子(Coze)实战案例：使用图像流做超分，模糊图片秒变清晰，完全免费教程

&#x1f9d9;‍♂️ 大家好&#xff0c;我是斜杠君&#xff0c;手把手教你搭建扣子AI应用。 &#x1f4dc; 本教程是《AI应用开发系列教程之扣子(Coze)实战教程》&#xff0c;完全免费学习。 &#x1f440; 关注斜杠君&#xff0c;可获取完整版教程。&#x1f44d;&#x1f3f…
阅读更多...
Mysql中间件和高可用

Mysql中间件和高可用

文章目录 一、MySQL中间件代理服务器MycatMycat应用场景Mycat部署 实现读写分离 二、MySQL高可用高可用解决方案MHA高可用实现MHA 一、MySQL中间件代理服务器 数据库主要分为两大类&#xff1a;关系型数据库与 NoSQL 数据库&#xff08;非关系型数据库&#xff09;。 数据库主…
阅读更多...
软考中级数据库系统工程师备考经验分享

软考中级数据库系统工程师备考经验分享

前几天软考成绩出了&#xff0c;赶紧查询了一下发现自己顺利通过啦&#xff08;上午63&#xff0c;下午67&#xff0c;开心&#xff09;&#xff0c;因此本文记录一下我的备考经验分享给大家。因为工作中项目管理类的知识没有系统学习过&#xff0c;本来想直接报名软考高级证书…
阅读更多...
7.6第三天作业

7.6第三天作业

一、在数据库中创建一个表student&#xff0c;用于存储学生信息 CREATE TABLE student( id INT PRIMARY KEY, name VARCHAR(20) NOT NULL, grade FLOAT ); &#xff08;1.&#xff09;先创建一个数据库 &#xff08;2.&#xff09;创建student表 查看是否创建成功 1、向studen…
阅读更多...
2024年软件测试八股文（含答案）

2024年软件测试八股文（含答案）

Part1 1、你的测试职业发展是什么&#xff1f; 测试经验越多&#xff0c;测试能力越高。所以我的职业发展是需要时间积累的&#xff0c;一步步向着高级测试工程师奔去。而且我也有初步的职业规划&#xff0c;前3年积累测试经验&#xff0c;按如何做好测试工程师的要点去要求自…
阅读更多...
基于SpringBoot+Vue的招生管理系统(带1w+文档）

基于SpringBoot+Vue的招生管理系统(带1w+文档）

基于SpringBootVue的招生管理系统(带1w文档&#xff09; 通过招生管理系统的研究可以更好地理解系统开发的意义&#xff0c;而且也有利于发展更多的智能系统&#xff0c;解决了人才的供给和需求的平衡问题&#xff0c;招生管理系统的开发建设&#xff0c;由于其开发周期短&…
阅读更多...
NLP简介

NLP简介

自然语言处理( Natural Language Processing, NLP)是计算机科学领域与人工智能领域中的一个重要方向。它研究能实现人与计算机之间用自然语言进行有效通信的各种理论和方法。自然语言处理是一门融语言学、计算机科学、数学于一体的科学。因此&#xff0c;这一领域的研究将涉及自…
阅读更多...
2.pwn的linux基础（计算机内部数据结构存储形式）

2.pwn的linux基础（计算机内部数据结构存储形式）

linux基础 保护层级: 分为四个ring0-ring3 一般来说就两个&#xff0c;0和3 0为内核 3为用户 权限: 用户分为多个组 文件和目录等等的权限一般都是三个&#xff0c;即可读可写可执行。 读:R&#xff0c;写:W&#xff0c;执行:X 赋予一个可执行文件执行权限就是chmod x file…
阅读更多...
快手大模型首次集体亮相，用AI重塑内容与商业生态

快手大模型首次集体亮相，用AI重塑内容与商业生态

7月6日&#xff0c;在2024世界人工智能大会期间&#xff0c;快手举办了以“新AI新应用新生态”为主题的大模型论坛&#xff0c;会上&#xff0c;快手大模型首次集体亮相&#xff0c;视频生成大模型可灵、图像生成大模型可图等产品的多项新功能正式发布。 继图生视频、视频续写…
阅读更多...
python-开关灯（赛氪OJ）

python-开关灯（赛氪OJ）

[题目描述] 假设有 N 盏灯&#xff08;N 为不大于 5000 的正整数&#xff09;&#xff0c;从 1 到到 N 按顺序依次编号&#xff0c;初始时全部处于开启状态&#xff1b;第一个人&#xff08; 1 号&#xff09;将灯全部关闭&#xff0c;第二个人&#xff08; 2 号&#xff09;将…
阅读更多...
有趣的算法

有趣的算法

目录&#xff1a; 1、百钱买百鸡 2、韩信点兵 1&#xff09;概述 2&#xff09;正常取余算法 3&#xff09;循环算法 1、百钱买百鸡 我国古代《算经》中的“百钱买百鸡”问题&#xff1a; 鸡翁一&#xff0c;值钱五&#xff1b;鸡母一&#xff0c;值钱三&#xff1b;鸡…
阅读更多...
【第21章】MyBatis-Plus多数据源支持

【第21章】MyBatis-Plus多数据源支持

文章目录 前言一、dynamic-datasource1. 特性2. 约定3. 使用方法3.1 引入依赖3.2 配置数据源3.3 使用 DS 切换数据源 二、mybatis-mate1.特性2.使用方法2.1 配置数据源2.2 使用 Sharding 切换数据源2.3 切换指定数据库节点 三、实战1. 引入库2. 配置3. 使用 DS 切换数据源4. 测…
阅读更多...
vulhub-activemq(CVE-2015-5254)

vulhub-activemq(CVE-2015-5254)

Apache ActiveMQ 5.13.0版本之前到5.x版本的安全漏洞&#xff0c;该程序引起的漏洞不限制代理中可以序列化的类。远程攻击者可以制作一个特殊的序列化 Java 消息服务 (JMS) ObjectMessage 对象&#xff0c;利用该漏洞执行任意代码。 Apache ActiveMQ 5.x ~ Apache ActiveMQ 5.1…
阅读更多...
Faster-RCNN·代码解读系列01：Selective Search 和 R-CNN、Fast-CNN 简介

Faster-RCNN·代码解读系列01：Selective Search 和 R-CNN、Fast-CNN 简介

Selective Search 和 R-CNN、Fast-CNN 简介 1 目标检测算法简介1.0滑窗法的思路1.1 Selective Search 和 R-CNN 简介1.2.1 Selective Search简介1.1.1 Selective Search的思路1.1.2 Selective Search图解 1.2 Selective Search 和 Fast-CNN简介1.2.1 SPP和ROI Pooling简介1.2.2…
阅读更多...
MySQL/SqlServer 跨服务器 增删改查（CRUD） 的一种方法

MySQL/SqlServer 跨服务器 增删改查（CRUD） 的一种方法

前言&#xff1a;主要是利用SqlServer 的链接服务器功能 1.准备一台 SqlServer Server&#xff0c;服务如下图&#xff1a; 这台服务器专门用于 链接服务器 IP&#xff1a;10.x.x.3 和数据源服务器&#xff08;10.x.x.5&#xff09; 在一个局域网 1.1 版本 是 2017 2.在 10.…
阅读更多...
监控平台zabbix对接grafana

监控平台zabbix对接grafana

目录 1.安装grafana并启动 2.浏览器访问 3.导入zabbix数据&#xff0c;对接grafana 4.如何导入模板 5.使用zabbix监控nginx并发量连接数 5.1 修改nginx配置 5.2 编写监控数据脚本 5.3 设置键值 5.4 在zabbix web端完成自定义监控项 5.5 连接到grafana 以上一篇博客&l…
阅读更多...
前端面试题7（单点登录）

前端面试题7（单点登录）

如何实现单点登录 单点登录&#xff08;Single Sign-On&#xff0c;简称SSO&#xff09;是一种允许用户在多个应用系统中只需登录一次&#xff0c;就可以访问所有相互信任的应用系统的认证技术。实现前端单点登录主要依赖于后端的支持和一些特定的协议&#xff0c;如OAuth、Ope…
阅读更多...
使用Github Actions自建Docker镜像仓库

使用Github Actions自建Docker镜像仓库

使用Github Actions自建Docker镜像仓库 背景使用Github Actions自建Docker镜像仓库fork项目[docker_image_sync](https://github.com/xqxyxchy/docker_image_sync)获取云厂商容器镜像服务信息配置github secrets运行github action配置需要同步的镜像同步后效果华为云配置 背景 …
阅读更多...
一.1.（3）半导体二极管基本电路的分析方法及常见应用电路

一.1.（3）半导体二极管基本电路的分析方法及常见应用电路

1.二极管基本电路的分析方法 先标正负极&#xff0c;再看是否理想二极管 将二极管视为断路&#xff0c;求两端电压 两端电压均大于导通电压&#xff0c;压差大的先导通&#xff08;由于电源不是完全的阶跃&#xff0c;而是有一个电压爬升的过程&#xff09; 2.常见应用电路 1.求…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023