规则文本数据文件根据关键字段进行排序的实现

快速排序（Quick Sort）是一种改进的排序算法，其平均性能在各种排序算法中最优而被广泛使用。STL中的sort就是对快速排序的一种非递归实现。在嵌入式平台，特别是部分基于DOS的低端嵌入式系统而言，由于编译器年代久远，对C++标准支持都相去甚远，更不可能有STL了，特别是在实模式，并且CPU速度较低，系统的内存和存储空间都紧缺情况下。另外，DBMS在嵌入式上是一种奢侈，即使有嵌入式DB，但在低端系统上也很难得以应用，所以大部分低端嵌入式设备都采用的简单文本方式来存取数据。下面我会自行实现2个CLASS用以在一个数据规则格式文本文件中进行快速排序算法（递归方式）并输出排序后的文件。

代码如下（在Borland C++ 5.02中编译通过）：

#include <string.h>
#include <iostream.h>
#include <conio.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
//#include <unistd.h>

//类名：MsgPair
//作用：储存一个键值对（int,char*）
class MsgPair
{
public:
~MsgPair();
MsgPair();
MsgPair(int i, const char* pc);
void SetPair(int i, const char* pc);
int No() const{return _no;};
void No(int i) {_no = i;};
const char* Msg() const{return _msg;};
void Msg(const char* pc);
MsgPair& operator=(MsgPair& mp);

private:
int _no;
char *_msg;
};

/* public function */

MsgPair::~MsgPair()
{
delete[] _msg;
_msg = NULL;
_no = 0;
}

MsgPair::MsgPair()
{
_no = 0;
_msg = NULL;
}

MsgPair::MsgPair(int i, const char* pc)
{
SetPair(i, pc);
}

//重载=操作符，赋值给this对象（深拷贝）
MsgPair& MsgPair::operator=(MsgPair& mp)
{
if(&mp == NULL)
{
delete[] _msg;
_msg = NULL;
_no = 0;
}
else
{
_no = mp._no;
delete[] _msg;
_msg = new char[strlen(mp._msg) + 1];
strcpy(_msg, mp._msg);
}
return *this;
}

//重新给该键值对复制（深拷贝）
void MsgPair::SetPair(int i, const char* pc)
{
_no = i;
_msg = NULL;
Msg(pc);
}

//设置_msg私有字段（深拷贝）
void MsgPair::Msg(const char* pc)
{
if(_msg != NULL)
delete[] _msg;
if(strlen(pc) > 0)
{
_msg = new char[strlen(pc)+1];
strcpy(_msg, pc);
}
}
/* End of Class MsgPair */

//类名：MsgQuickSort
//作用：用快速排序算法对一个规则数据文本文件进行排序，把排序后的数据输出到指定文件
class MsgQuickSort
{
public:
~MsgQuickSort();
MsgQuickSort(const char* filename, int lineLength, int msgOffset, int msgLength);
void SetMsgFormat(const char*filename, int lineLength, int msgOffset, int msgLength);
int LoadMsgFromFile();
int ParseMsg(FILE* fp);
long GetFileSize(FILE *fp);
int Sort();
void DisplayAll();
int SaveToFile(const char* filename);

private:
int Partition(MsgPair *(&mp), int low, int high);
void QSort(MsgPair *(&mp), int low, int high);
unsigned int _msgPairNum;
MsgPair* _pMsgPair;
const char* _filename;
int _lineLength, _msgOffset, _msgLength;
};

/* public function */

MsgQuickSort::~MsgQuickSort()
{
delete[] _filename;
_filename = NULL;
delete[] _pMsgPair;
_pMsgPair = NULL;
}
MsgQuickSort::MsgQuickSort(const char* filename, int lineLength, int msgOffset, int msgLength)
{
_pMsgPair = NULL;
_filename = NULL;
_msgPairNum = 0;
SetMsgFormat(filename, lineLength, msgOffset, msgLength);
}

//设置数据规则（filename=文件名； lineLength=行长度（注意行结束符）； msgOffset=关键字偏移量； msgLength=关键字长度）
void MsgQuickSort::SetMsgFormat(const char*filename, int lineLength, int msgOffset, int msgLength)
{
_lineLength = lineLength;
_msgOffset = msgOffset;
_msgLength = msgLength;

if(_filename != NULL)
{
delete[] _filename;
_filename = NULL;
}
_filename = new char[strlen(filename) + 1];
strcpy((char*)_filename, filename);
}

//从文件中加载关键字段数据到内存中
int MsgQuickSort::LoadMsgFromFile()
{
FILE *fp;
int ret = 0;
fp = fopen(_filename, "rb");
if(fp != NULL)
{
ret = ParseMsg(fp);
fclose(fp);
}
return ret;
}

//获得文件大小
long MsgQuickSort::GetFileSize(FILE *fp)
{
struct stat buf;
fstat(fileno(fp), &buf);
return buf.st_size;
}

//提取关键字，保存到内存
int MsgQuickSort::ParseMsg(FILE* fp)
{
long fileSize = 0;
char *msg = NULL;

if(fp == NULL)
return -1;

msg = new char[_msgLength + 1];
fileSize = GetFileSize(fp);
_msgPairNum = (fileSize / _lineLength); //一共多少行
_pMsgPair = new MsgPair[_msgPairNum];
for(unsigned int i = 0; i < _msgPairNum; i++)
{
memset(msg, 0, _msgLength + 1);
fseek(fp, long((i * _lineLength) + _msgOffset), SEEK_SET);
fread(msg, 1, _msgLength, fp);
_pMsgPair[i].SetPair(i, msg); //MsgPair从第0开始，到uiMaxItem - 1结束
}
delete[] msg;
return 1;
}

//显示当前内存中的关键数据，以及它对应加载文件的行号（从第0行开始）
void MsgQuickSort::DisplayAll()
{
for(unsigned int i = 0; i < _msgPairNum; i++)
{
printf("[%05d]:[%s]\r\n", _pMsgPair[i].No(), _pMsgPair[i].Msg());
}
}

// 保存当前的顺序到文件（未执行排序函数将保持原顺序）
int MsgQuickSort::SaveToFile(const char* saveFilename)
{
char *msg = NULL;
FILE *fp_save;
FILE *fp_from;
unlink(saveFilename);
fp_save = fopen(saveFilename, "ab");
fp_from = fopen(_filename, "rb");
if(fp_save == NULL)
return -1;
else if(fp_from == NULL)
{
fclose(fp_save);
return -1;
}
msg = new char[_lineLength + 1];
for(unsigned int i = 0; i < _msgPairNum; i++)
{
memset(msg, 0, _msgLength + 1);
fseek(fp_from, long(_pMsgPair[i].No() * _lineLength), SEEK_SET);
fread(msg, 1, _lineLength, fp_from);
fwrite(msg, 1, _lineLength, fp_save);
}
delete[] msg;
fclose(fp_save);
fclose(fp_from);
return 1;
}

//数据排序
int MsgQuickSort::Sort()
{
QSort(_pMsgPair, 0, _msgPairNum-1);
}

/* private function */
//快速排序法一趟排序
int MsgQuickSort::Partition(MsgPair *(&mp), int low, int high)
{
MsgPair pivotkey;
pivotkey = mp[low];

while(low<high)
{
while(low<high && strcmp(mp[high].Msg(), pivotkey.Msg()) >= 0)
{
--high;
}
mp[low] = mp[high];
while(low<high && strcmp(mp[low].Msg(), pivotkey.Msg()) <= 0)
{
++low;
}
mp[high] = mp[low];
}
mp[low] = pivotkey;
return low;
}

//快速排序递归函数
void MsgQuickSort::QSort(MsgPair *(&mp), int low, int high)
{
if(low < high)
{
int pivotloc = Partition(mp, low, high);
QSort(mp, low, pivotloc-1);
QSort(mp, pivotloc+1, high);
}
}

/* End Of Class MsgQuickSort */

/* Test */
int main()
{

MsgQuickSort mqs("msg.txt", 41, 0, 10); //待排文件msg.txt；每行41个字节；关键字行中偏移0，长度10字节
mqs.LoadMsgFromFile(); //加载文件中的关键字到内存
mqs.Sort(); //快速排序(这里是按关键字的ASCII码进行排序)
mqs.DisplayAll(); //显示目前的关键字顺序（排序后）
mqs.SaveToFile("sortmsg.txt"); //把根据关键字进行排序后的数据保存到sortmsg.txt文件

getch();
return 0;
}

msg.txt示例：
7905C5AEFC06120720503312018162236739999
7903FADFF106120720504012018162236739999
7F7F56E23006120720505212018162236739999
7A9686FB5106120720505412018162236739999
7A4C7B723F06120720505512018162236739999
79093698CA06120720505612018162236739999
7A9686FB5106120720505412018162236739999
7A4C7B723F06120720505512018162236739999
79093698CA06120720505612018162236739999
7A9686FB5106120720505412018162236739999
7A4C7B723F06120720505512018162236739999

sortmsg.txt输出：
7903FADFF106120720504012018162236739999
7905C5AEFC06120720503312018162236739999
79093698CA06120720505612018162236739999
79093698CA06120720505612018162236739999
7A4C7B723F06120720505512018162236739999
7A4C7B723F06120720505512018162236739999
7A4C7B723F06120720505512018162236739999
7A9686FB5106120720505412018162236739999
7A9686FB5106120720505412018162236739999
7A9686FB5106120720505412018162236739999
7F7F56E23006120720505212018162236739999

实现过程分析：
1、快速排序（Quick Sort）在各种排序方案中的平均时间效率最高。
2、因为嵌入式系统中多用FLASH（主要是NOR和NAND）进行存取，尽可能应该减少FLASH读写，在内存中处理效率高且磨损率低。所以采用对应原文件行号+关键字方式读取到内存中进行排序处理，然后根据排序后的顺序，通过对应原文件行号，进行查找输出后保存。一般来说，即使低端嵌入式，上DOS系统后，总内存空间也应该在512KB左右，FLASH也至少应该采用1MB（保证正常操作系统以及主程序存放），按照本例子，关键字10字节，假设有1W行数据，进行上述运算时候占内存约=10*10K=100KB。
3、另外，在老编译器下，没有简单且现成的可用方案来避免内存碎片（主要指外部碎片）的分配工具，基于这种情况，在MsgQuickSort的生存周期内，尽可能不要插入其他涉及动态分配内存语句，以此也可以减少在这过程中产生的内存碎片（外部碎片）的几率。