基于C#实现外排序

news2024/12/25 13:58:38

一、N 路归并排序

1.1、概序

我们知道算法中有一种叫做分治思想,一个大问题我们可以采取分而治之,各个突破,当子问题解决了,大问题也就 KO 了,还有一点我们知道内排序的归并排序是采用二路归并的,因为分治后有 LogN 层,每层两路归并需要 N 的时候,最后复杂度为 NlogN,那么外排序我们可以将这个“二”扩大到 M,也就是将一个大文件分成 M 个小文件,每个小文件是有序的,然后对应在内存中我们开 M 个优先队列,每个队列从对应编号的文件中读取 TopN 条记录,然后我们从 M 路队列中各取一个数字进入中转站队列,并将该数字打上队列编号标记,当从中转站出来的最小数字就是我们最后要排序的数字之一,因为该数字打上了队列编号,所以方便我们通知对应的编号队列继续出数字进入中转站队列,可以看出中转站一直保存了 M 个记录,当中转站中的所有数字都出队完毕,则外排序结束。如果大家有点蒙的话,我再配合一张图,相信大家就会一目了然,这考验的是我们的架构能力。
image.png
图中这里有个 Batch 容器,这个容器我是基于性能考虑的,当 batch=n 时,我们定时刷新到文件中,保证内存有足够的空间。

1.2、构建

<1> 生成数据
这个基本没什么好说的,采用随机数生成 n 条记录。 
<2> 切分数据
根据实际情况我们来决定到底要分成多少个小文件,并且小文件的数据必须是有序的,小文件的个数也对应这内存中有多少个优先队列。 
<3> 加入队列
我们知道内存队列存放的只是小文件的 topN 条记录,当内存队列为空时,我们需要再次从小文件中读取下一批的 TopN 条数据,然后放入中转站继续进行比较。
<4> 测试
最后我们来测试一下:
数据量:short.MaxValue。
内存存放量:1200。
在这种场景下,我们决定每个文件放 1000 条,也就有 33 个小文件,也就有 33 个内存队列,每个队列取 Top100 条,Batch=500 时刷新
硬盘,中转站存放 332 个数字(因为入中转站时打上了队列标记),最后内存活动最大总数为:sum=33100+500+66=896<1200。
时间复杂度为 N*logN。
image.png
总的代码:

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Diagnostics;
 using System.Threading;
 using System.IO;
 using System.Threading.Tasks;
 
 namespace ConsoleApplication2
 {
     public class Program
     {
         public static void Main()
         {
             //生成2^15数据
             CreateData(short.MaxValue);
 
             //每个文件存放1000条
             var pageSize = 1000;
 
             //达到batchCount就刷新记录
             var batchCount = 0;
 
             //判断需要开启的队列
             var pageCount = Split(pageSize);
 
             //内存限制:1500条
             List<PriorityQueue<int?>> list = new List<PriorityQueue<int?>>();
 
             //定义一个队列中转器
             PriorityQueue<int?> queueControl = new PriorityQueue<int?>();
 
             //定义每个队列完成状态
             bool[] complete = new bool[pageCount];
 
             //队列读取文件时应该跳过的记录数
             int[] skip = new int[pageCount];
 
             //是否所有都完成了
             int allcomplete = 0;
 
             //定义 10 个队列
             for (int i = 0; i < pageCount; i++)
             {
                 list.Add(new PriorityQueue<int?>());
 
                 //i:   记录当前的队列编码
                 //list: 队列数据
                 //skip:跳过的条数
                 AddQueue(i, list, ref skip);
             }
 
             //初始化操作,从每个队列中取出一条记录,并且在入队的过程中
             //记录该数据所属的 “队列编号”
             for (int i = 0; i < list.Count; i++)
             {
                 var temp = list[i].Dequeue();
 
                 //i:队列编码,level:要排序的数据
                 queueControl.Eequeue(i, temp.level);
             }
 
             //默认500条写入一次文件
             List<int> batch = new List<int>();
 
             //记录下次应该从哪一个队列中提取数据
             int nextIndex = 0;
 
             while (queueControl.Count() > 0)
             {
                 //从中转器中提取数据
                 var single = queueControl.Dequeue();
 
                 //记录下一个队列总应该出队的数据
                 nextIndex = single.t.Value;
 
                 var nextData = list[nextIndex].Dequeue();
 
                 //如果改对内弹出为null,则说明该队列已经,需要从nextIndex文件中读取数据
                 if (nextData == null)
                 {
                     //如果该队列没有全部读取完毕
                     if (!complete[nextIndex])
                     {
                         AddQueue(nextIndex, list, ref skip);
 
                         //如果从文件中读取还是没有,则说明改文件中已经没有数据了
                         if (list[nextIndex].Count() == 0)
                         {
                             complete[nextIndex] = true;
                             allcomplete++;
                         }
                         else
                         {
                             nextData = list[nextIndex].Dequeue();
                         }
                     }
                 }
 
                 //如果弹出的数不为空,则将该数入中转站
                 if (nextData != null)
                 {
                     //将要出队的数据 转入 中转站
                     queueControl.Eequeue(nextIndex, nextData.level);
                 }
 
                 batch.Add(single.level);
 
                 //如果batch=500,或者所有的文件都已经读取完毕,此时我们要批量刷入数据
                 if (batch.Count == batchCount || allcomplete == pageCount)
                 {
                     var sw = new StreamWriter(Environment.CurrentDirectory + "//result.txt", true);
 
                     foreach (var item in batch)
                     {
                         sw.WriteLine(item);
                     }
 
                     sw.Close();
 
                     batch.Clear();
                 }
             }
 
             Console.WriteLine("恭喜,外排序完毕!");
             Console.Read();
         }
 
         #region 将数据加入指定编号队列
         /// <summary>
         /// 将数据加入指定编号队列
         /// </summary>
         /// <param name="i">队列编号</param>
         /// <param name="skip">文件中跳过的条数</param>
         /// <param name="list"></param>
         /// <param name="top">需要每次读取的条数</param>
         public static void AddQueue(int i, List<PriorityQueue<int?>> list, ref int[] skip, int top = 100)
         {
             var result = File.ReadAllLines((Environment.CurrentDirectory + "//" + (i + 1) + ".txt"))
                              .Skip(skip[i]).Take(top).Select(j => Convert.ToInt32(j));
 
             //加入到集合中
             foreach (var item in result)
                 list[i].Eequeue(null, item);
 
             //将个数累计到skip中,表示下次要跳过的记录数
             skip[i] += result.Count();
         }
         #endregion
 
         #region 随机生成数据
         /// <summary>
         /// 随机生成数据
         ///<param name="max">执行生成的数据上线</param>
         /// </summary>
         public static void CreateData(int max)
         {
             var sw = new StreamWriter(Environment.CurrentDirectory + "//demo.txt");
 
             for (int i = 0; i < max; i++)
             {
                 Thread.Sleep(2);
                 var rand = new Random((int)DateTime.Now.Ticks).Next(0, int.MaxValue >> 3);
 
                 sw.WriteLine(rand);
             }
             sw.Close();
         }
         #endregion
 
         #region 将数据进行分份
         /// <summary>
         /// 将数据进行分份
         /// <param name="size">每页要显示的条数</param>
         /// </summary>
         public static int Split(int size)
         {
             //文件总记录数
             int totalCount = 0;
 
             //每一份文件存放 size 条 记录
             List<int> small = new List<int>();
 
             var sr = new StreamReader((Environment.CurrentDirectory + "//demo.txt"));
 
             var pageSize = size;
 
             int pageCount = 0;
 
             int pageIndex = 0;
 
             while (true)
             {
                 var line = sr.ReadLine();
 
                 if (!string.IsNullOrEmpty(line))
                 {
                     totalCount++;
 
                     //加入小集合中
                     small.Add(Convert.ToInt32(line));
 
                     //说明已经到达指定的 size 条数了
                     if (totalCount % pageSize == 0)
                     {
                         pageIndex = totalCount / pageSize;
 
                         small = small.OrderBy(i => i).Select(i => i).ToList();
 
                         File.WriteAllLines(Environment.CurrentDirectory + "//" + pageIndex + ".txt", small.Select(i => i.ToString()));
 
                         small.Clear();
                     }
                 }
                 else
                 {
                     //说明已经读完了,将剩余的small记录写入到文件中
                     pageCount = (int)Math.Ceiling((double)totalCount / pageSize);
 
                     small = small.OrderBy(i => i).Select(i => i).ToList();
 
                     File.WriteAllLines(Environment.CurrentDirectory + "//" + pageCount + ".txt", small.Select(i => i.ToString()));
 
                     break;
                 }
             }
 
             return pageCount;
         }
         #endregion
     }
 }

优先队列:

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Diagnostics;
 using System.Threading;
 using System.IO;
 
 namespace ConsoleApplication2
 {
     public class PriorityQueue<T>
     {
         /// <summary>
         /// 定义一个数组来存放节点
         /// </summary>
         private List<HeapNode> nodeList = new List<HeapNode>();
 
         #region 堆节点定义
         /// <summary>
         /// 堆节点定义
         /// </summary>
         public class HeapNode
         {
             /// <summary>
             /// 实体数据
             /// </summary>
             public T t { get; set; }
 
             /// <summary>
             /// 优先级别 1-10个级别 (优先级别递增)
             /// </summary>
             public int level { get; set; }
 
             public HeapNode(T t, int level)
             {
                 this.t = t;
                 this.level = level;
             }
 
             public HeapNode() { }
         }
         #endregion
 
         #region  添加操作
         /// <summary>
         /// 添加操作
         /// </summary>
         public void Eequeue(T t, int level = 1)
         {
             //将当前节点追加到堆尾
             nodeList.Add(new HeapNode(t, level));
 
             //如果只有一个节点,则不需要进行筛操作
             if (nodeList.Count == 1)
                 return;
 
             //获取最后一个非叶子节点
             int parent = nodeList.Count / 2 - 1;
 
             //堆调整
             UpHeapAdjust(nodeList, parent);
         }
         #endregion
 
         #region 对堆进行上滤操作,使得满足堆性质
         /// <summary>
         /// 对堆进行上滤操作,使得满足堆性质
         /// </summary>
         /// <param name="nodeList"></param>
         /// <param name="index">非叶子节点的之后指针(这里要注意:我们
         /// 的筛操作时针对非叶节点的)
         /// </param>
         public void UpHeapAdjust(List<HeapNode> nodeList, int parent)
         {
             while (parent >= 0)
             {
                 //当前index节点的左孩子
                 var left = 2 * parent + 1;
 
                 //当前index节点的右孩子
                 var right = left + 1;
 
                 //parent子节点中最大的孩子节点,方便于parent进行比较
                 //默认为left节点
                 var min = left;
 
                 //判断当前节点是否有右孩子
                 if (right < nodeList.Count)
                 {
                     //判断parent要比较的最大子节点
                     min = nodeList[left].level < nodeList[right].level ? left : right;
                 }
 
                 //如果parent节点大于它的某个子节点的话,此时筛操作
                 if (nodeList[parent].level > nodeList[min].level)
                 {
                     //子节点和父节点进行交换操作
                     var temp = nodeList[parent];
                     nodeList[parent] = nodeList[min];
                     nodeList[min] = temp;
 
                     //继续进行更上一层的过滤
                     parent = (int)Math.Ceiling(parent / 2d) - 1;
                 }
                 else
                 {
                     break;
                 }
             }
         }
         #endregion
 
         #region 优先队列的出队操作
         /// <summary>
         /// 优先队列的出队操作
         /// </summary>
         /// <returns></returns>
         public HeapNode Dequeue()
         {
             if (nodeList.Count == 0)
                 return null;
 
             //出队列操作,弹出数据头元素
             var pop = nodeList[0];
 
             //用尾元素填充头元素
             nodeList[0] = nodeList[nodeList.Count - 1];
 
             //删除尾节点
             nodeList.RemoveAt(nodeList.Count - 1);
 
             //然后从根节点下滤堆
             DownHeapAdjust(nodeList, 0);
 
             return pop;
         }
         #endregion
 
         #region  对堆进行下滤操作,使得满足堆性质
         /// <summary>
         /// 对堆进行下滤操作,使得满足堆性质
         /// </summary>
         /// <param name="nodeList"></param>
         /// <param name="index">非叶子节点的之后指针(这里要注意:我们
         /// 的筛操作时针对非叶节点的)
         /// </param>
         public void DownHeapAdjust(List<HeapNode> nodeList, int parent)
         {
             while (2 * parent + 1 < nodeList.Count)
             {
                 //当前index节点的左孩子
                 var left = 2 * parent + 1;
 
                 //当前index节点的右孩子
                 var right = left + 1;
 
                 //parent子节点中最大的孩子节点,方便于parent进行比较
                 //默认为left节点
                 var min = left;
 
                 //判断当前节点是否有右孩子
                 if (right < nodeList.Count)
                 {
                     //判断parent要比较的最大子节点
                     min = nodeList[left].level < nodeList[right].level ? left : right;
                 }
 
                 //如果parent节点小于它的某个子节点的话,此时筛操作
                 if (nodeList[parent].level > nodeList[min].level)
                 {
                     //子节点和父节点进行交换操作
                     var temp = nodeList[parent];
                     nodeList[parent] = nodeList[min];
                     nodeList[min] = temp;
 
                     //继续进行更下一层的过滤
                     parent = min;
                 }
                 else
                 {
                     break;
                 }
             }
         }
         #endregion
 
         #region 获取元素并下降到指定的level级别
         /// <summary>
         /// 获取元素并下降到指定的level级别
         /// </summary>
         /// <returns></returns>
         public HeapNode GetAndDownPriority(int level)
         {
             if (nodeList.Count == 0)
                 return null;
 
             //获取头元素
             var pop = nodeList[0];
 
             //设置指定优先级(如果为 MinValue 则为 -- 操作)
             nodeList[0].level = level == int.MinValue ? --nodeList[0].level : level;
 
             //下滤堆
             DownHeapAdjust(nodeList, 0);
 
             return nodeList[0];
         }
         #endregion
 
         #region 获取元素并下降优先级
         /// <summary>
         /// 获取元素并下降优先级
         /// </summary>
         /// <returns></returns>
         public HeapNode GetAndDownPriority()
         {
             //下降一个优先级
             return GetAndDownPriority(int.MinValue);
         }
         #endregion
 
         #region 返回当前优先队列中的元素个数
         /// <summary>
         /// 返回当前优先队列中的元素个数
         /// </summary>
         /// <returns></returns>
         public int Count()
         {
             return nodeList.Count;
         }
         #endregion
     }
 }

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

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

相关文章

【Redis基础】Redis安装及管理详细教程

✅作者简介&#xff1a;大家好&#xff0c;我是小杨 &#x1f4c3;个人主页&#xff1a;「小杨」的csdn博客 &#x1f433;希望大家多多支持&#x1f970;一起进步呀&#xff01; 1&#xff0c;UBuntu安装Redis 1&#xff0c;使用su命令切换到root用户 su2&#xff0c;使用se…

windows运行Pangolin应用填坑心得——如何在window应用轻量级opengl软件Pangolin库显示3D界面及窗口

目录 0、前言1、最有效的安装打开方式准备工作安装git安装vcpkg&#xff08;1&#xff09;下载&#xff08;2&#xff09;安装&#xff08;3&#xff09;集成至vs 安装cmake 安装pangolin 2、应用实例c工程&#xff08;1&#xff09;vs创建新工程&#xff08;2&#xff09;新工…

盘点60个Python爬虫源码Python爱好者不容错过

盘点60个Python爬虫源码Python爱好者不容错过 爬虫&#xff08;Spider&#xff09; 学习知识费力气&#xff0c;收集整理更不易。 知识付费甚欢喜&#xff0c;为咱码农谋福利。 链接&#xff1a;https://pan.baidu.com/s/1JWrDgl46_ammprQaJiKqaQ?pwd8888 提取码&#xff…

Mysql并发时常见的死锁及解决方法

使用数据库时&#xff0c;有时会出现死锁。对于实际应用来说&#xff0c;就是出现系统卡顿。 死锁是指两个或两个以上的事务在执行过程中&#xff0c;因争夺资源而造成的一种互相等待的现象。就是所谓的锁资源请求产生了回路现象&#xff0c;即死循环&#xff0c;此时称系统处于…

2023 年 认证杯 小美赛 国际大学生数学建模挑战赛 |数学建模完整代码+建模过程全解全析

当大家面临着复杂的数学建模问题时&#xff0c;你是否曾经感到茫然无措&#xff1f;作为2022年美国大学生数学建模比赛的O奖得主&#xff0c;我为大家提供了一套优秀的解题思路&#xff0c;让你轻松应对各种难题。 cs数模团队在认证杯 小美赛前为大家提供了许多资料的内容呀&am…

数字图像处理(实践篇)一 将图像中的指定目标用bBox框起来吧!

目录 一 实现方法 二 涉及的OpenCV函数 三 代码 四 效果图 一 实现方法 ①利用OTSU方法将前景与背景分割。 ②使用连通区域分析可以将具有相同像素值且位置相邻的前景像素点组成的图像区域识别。 ③画bbox。 ④显示结果。 二 涉及的OpenCV函数 ① OpenCV提供了cv2.th…

【小技巧】复制一个模块到你的工程(学习阶段很实用)

问题描述&#xff1a; 当我们学习Springboot时&#xff0c;需要创建大量的模块&#xff0c;而这些模块的许多代码都是重复的&#xff0c;只有模块名等相关的信息不一样&#xff0c;现在就教你如何快速创建一个模块。 应用场景&#xff1a; ①进入项目文件夹&#xff1a; ②复…

Android : 模仿西瓜视频_主页界面_简单应用

示例图&#xff1a; MainActivity.java package com.example.xihuashipingapp;import androidx.appcompat.app.AppCompatActivity;import android.os.Bundle; import android.util.DisplayMetrics; import android.view.View; import android.widget.Button; import android.…

计算机组成原理(计算机系统概述)

目录 一. 计算机的发展二. 计算机硬件的基本组成2.1 早期冯诺依曼机2.2 现代计算机的结构 三. 各硬件的工作原理3.1 主存储器的基本组成3.2 运算器的基本组成3.3 控制器的基本组成 四. 计算机的工作过程 \quad 一. 计算机的发展 计算机系统 硬件 软件 #mermaid-svg-gp2AsYELE…

如何搭建zerotier服务器组网实现内网穿透

小白花了四天的下班时间终于把zerotier网络调通&#xff0c;此刻坐在桌前舒畅地喝口茶&#xff5e;&#xff5e; 下面来详细记录下这几天踩的坑&#xff1a; 起因就在于一直在iPad上用向日葵连接公司电脑的我觉得向日葵的界面用的实在难受&#xff0c;vs code操作十分不灵光&…

Windows核心编程 线程

目录 线程概述 进程与线程的关系 线程调度原理 单核与多核的线程处理方式 多线程 线程相关API 线程分配 线程切换时 线程状态 线程退出 线程退出时做的事&#xff08;正常退出情况&#xff09; 线程概述 程序磁盘上的一个可执行文件&#xff08;由指令和数据等组成…

Flash Attention:高效注意力机制的突破与应用

注意力机制彻底改变了自然语言处理和深度学习领域。它们允许模型在执行机器翻译、语言生成等任务时专注于输入数据的相关部分。 在这篇博客[1]中&#xff0c;我们将深入研究被称为“Flash Attention”的注意力机制的突破性进展。我们将探讨它是什么、它是如何工作的&#xff0c…

赋值,浅拷贝,深拷贝

1.前置知识 数据分为基本类型(String, Number, Boolean, Null, Undefined&#xff0c;Symbol)和引用类型(Object)基本类型&#xff1a;直接存储在栈内存中的数据引用类型&#xff1a;指向改数据的指针变量存储在栈内存中&#xff0c;真实的数据存储在堆内存中引用类型在栈内存…

SpectralGPT: Spectral Foundation Model 论文翻译1

遥感领域的通用大模型 2023.11.13在CVPR发表 原文地址&#xff1a;[2311.07113] SpectralGPT: Spectral Foundation Model (arxiv.org) 摘要 ​ 基础模型最近引起了人们的极大关注&#xff0c;因为它有可能以一种自我监督的方式彻底改变视觉表征学习领域。虽然大多数基础模型…

河南省第一届职业技能大赛网络安全项目试题

河南省第一届职业技能大赛 网络安全项目试题 一、竞赛时间 总计&#xff1a;420分钟 竞赛阶段 竞赛阶段 任务阶段 竞赛任务 竞赛时间 分值 A模块 A-1 登录安全加固 240分钟 200分 A-2 Web安全加固&#xff08;Web&#xff09; A-3 流量完整性保护与事件监控&a…

Openwrt 包管理系统介绍

Openwrt 包管理系统介绍 1. OpenWrt简介1.1 主要特点1.2 开源嵌入式操作系统1.2.1 嵌入式系统概念1.2.2 嵌入式系统分类1.2.3 嵌入式系统——安卓1.2.4 嵌入式系统的对比 2 OpenWrt包管理系统2.1 工作原理2.2 OPKG命令2.2.1 命令用法2.2.2 软件包的管理2.2.3 查询信息2.2.4 选项…

ubuntu 编译linux webrtc库

ubuntu 编译linux webrtc库 安装依赖 sudo apt-get update sudo apt-get install build-essential libssl-dev libasound2-dev libpulse-dev libjpeg-dev libxv-dev libgtk-3-dev libxtst-dev libwebp-dev sudo apt-get install libglib2.0-dev sudo apt-get update 报错时出…

设计测试用例的具体方法总结

&#x1f4d1;打牌 &#xff1a; da pai ge的个人主页 &#x1f324;️个人专栏 &#xff1a; da pai ge的博客专栏 ☁️白马沉河共歃誓&#xff0c;怒涛没城亦不悔 ☁️基于需求进行测试用例的设计 基…

【Linux】匿名管道与命名管道,进程池的简易实现

文章目录 前言一、匿名管道1.管道原理2.管道的四种情况3.管道的特点 二、命名管道1. 特点2.创建命名管道1.在命令行上2.在程序中 3.一个程序执行打开管道并不会真正打卡 三、进程池简易实现1.makefile2.Task.hpp3.ProcessPool.cpp 前言 一、匿名管道 #include <unistd.h&g…

死磕Nacos系列:Nacos在我的SpringCloud项目中做了什么?

Nacos服务注册 我们一个SpringCloud项目中集成了Nacos&#xff0c;当项目启动成功后&#xff0c;就可以在Nacos管理界面上看到我们项目的注册信息&#xff0c;还可以看到项目的健康状态等等信息&#xff1a; 那Nacos是什么时候进行了哪些操作的呢&#xff1f;今天我们来一探究…