以下是一个基于类和对象的股票数据排序代码示例：
```
cpp
#
include <iostream>
#
include <fstream>
#
include <algorithm>
#
include <vector>
using namespace std;
const int MAX_MEM = 32 * 1024 * 1024; // 内存最大容量
const int MAX_
FILE = 100; // 最多分割成的
文件数
// 股票数据类
class StockData {
public:
string ts_code; // 股票代码
string trade_date; // 交易日期
double open; // 开盘价
double high; // 最高价
double low; // 最低价
double close; // 收盘价
double pre_close; // 临近收盘价
double change; // 涨跌幅
double pct_chg; // 涨跌百分比
double vol; // 交易量
double amount; // 交易金额
bool operator<(const StockData &other) const {
if (ts_code != other.ts_code) {
return ts_code < other.ts_code;
} else {
return trade_date < other.trade_date;
}
}
};
// 将内存
中的数据写入
文件
template<class T>
void outputTo
File(vector<T> &data, int len, int
fileNum) {
string
fileName = "temp" + to_string(
fileNum) + ".txt";
ofstream out
File(
fileName, ios::binary);
for (int i = 0; i < len; i++) {
out
File.write((char*)&data[i], sizeof(T));
}
out
File.close();
}
// 外部排序
template<class T>
void externalSort(string
fileName) {
// 读入
文件数据
ifstream in
File(
fileName, ios::binary);
T data;
vector<T> buffer;
int len = 0,
fileSize = 0;
in
File.read((char*)&data, sizeof(T));
while (!in
File.eof()) {
fileSize += sizeof(T);
buffer.push_back(data);
len++;
if (
fileSize >= MAX_MEM) {
// 内存已满，排序并写入
文件
sort(buffer.begin(), buffer.end());
outputTo
File(buffer, len,
fileNum);
len = 0;
fileSize = 0;
buffer.clear();
}
in
File.read((char*)&data, sizeof(T));
}
// 处理剩余数据
if (len > 0) {
sort(buffer.begin(), buffer.end());
outputTo
File(buffer, len,
fileNum);
}
in
File.close();
// 归并排序
while (
fileNum > 1) {
int mergeNum = (
fileNum + MAX_
FILE - 1) / MAX_
FILE;
for (int i = 0; i < mergeNum; i++) {
vector<ifstream>
files;
int
fileStart = i * MAX_
FILE;
int
fileEnd = min(
fileStart + MAX_
FILE,
fileNum);
for (int j =
fileStart; j <
fileEnd; j++) {
string
fileName = "temp" + to_string(j) + ".txt";
files.push_back(ifstream(
fileName, ios::binary));
}
// 归并排序
string out
FileName = "temp" + to_string(
fileNum) + ".txt";
ofstream out
File(out
FileName, ios::binary);
vector<T> values(
files.size());
while (true) {
int minIdx = -1;
for (int i = 0; i <
files.size(); i++) {
if (
files[i].read((char*)&values[i], sizeof(T))) {
if (minIdx == -1 || values[i] < values[minIdx]) {
minIdx = i;
}
}
}
if (minIdx == -1) {
break;
} else {
out
File.write((char*)&values[minIdx], sizeof(T));
}
}
for (int i = 0; i <
files.size(); i++) {
files[i].close();
}
out
File.close();
fileNum++;
}
}
// 输出排序后的结果
string final
FileName = "output.txt";
ofstream final
File(final
FileName);
ifstream sorted
File("temp0.txt", ios::binary);
while (sorted
File.read((char*)&data, sizeof(T))) {
final
File << data.ts_code << "," << data.trade_date << "," << data.open << ","
<< data.high << "," << data.low << "," << data.close << "," << data.pre_close << ","
<< data.change << "," << data.pct_chg << "," << data.vol << "," << data.amount << endl;
}
sorted
File.close();
final
File.close();
}
int main() {
string
fileName = "stock_data.txt";
vector<StockData> data;
ifstream in
File(
fileName);
string line;
getline(in
File, line); // 读取表头
while (getline(in
File, line)) {
StockData stock;
sscanf(line.c_str(), "%[^,],%[^,],%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf",
stock.ts_code.c_str(), stock.trade_date.c_str(), &stock.open, &stock.high, &stock.low,
&stock.close, &stock.pre_close, &stock.change, &stock.pct_chg, &stock.vol, &stock.amount);
data.push_back(stock);
}
in
File.close();
// 进行外部排序
externalSort<StockData>(
fileName);
return 0;
}
```
该程序定义了一个股票数据类 `StockData`，并使用模板函数实现了外部排序功能。具体实现过程如下：
1. 定义股票数据类 `StockData`，重载 `<` 运算符以便进行排序。
2. 定义模板函数 `outputTo
File`，将内存
中的数据写入
文件。
3. 定义模板函数 `externalSort`，进行外部排序。首先读入待排序
文件，将数据分块存入内存缓冲区。当内存缓冲区已满时，对缓冲区内的数据进行排序，并将排序后的数据写入
文件。最后处理剩余的数据。然后将所有的小
文件进行归并排序，每次归并时读取相应的
文件，将数据进行排序后写入一个新的
文件中。最后将所有的归并结果
文件合并成一个有序的
文件。
4. 读入股票数据，将其存储在一个 vector
中，并调用 `externalSort` 进行排序。
5. 输出排序后的结果
文件。
需要注意的是，由于股票数据
文件中的数据类型为浮点数，因此读写
文件时需要使用二进制模式。同时，为了保证排序的稳定性，需要先按照日期排序，再按照股票代码排序。
141
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
