#include <iomanip> //setw()等
#include <queue> //STL中的队列与优先队列
#include <deque> //STL中的双端队列
#include <bitset> //STL中的位集合
#include <algorithm> //STL中的通用算法
#include <ctime> //clock()等
#include <cstdarg> //提供宏va_start、va_arg、va_end，用于存取长参数表
#include <assert.h> //assert宏
C.h 几乎各程序都需要用到的文件包含宏命令和使用名空间
线性表：抽象的数据类型。
逻辑结构：除第一个元素外，每个元素都有一个前驱；除最后一个元素外，每个元素都有一个后驱。
物理结构：顺序、单链、双向链。
STL：vector（顺序表）、list（链表）。
特点：易实现随机查找；但插入或删除时操作复杂。
适用于稳定的线性表，例如职工工资表、学生学籍表。
头文件：
SqList.h 顺序表的类（SqList类）
Func1-1.h 5个常用的函数
Func1-2.h 定义模板的实参Student及对其的I/O操作
//SqList.h 顺序表的类（SqList类）
SqList(const SqList &L) //拷贝构造函数
SqList& operator=(const SqList &L) //重载赋值运算符
{
以上俩个函数关键在于：
1、若成员数据中有指针数据，则需额外申请空间，以创造两个对象。
2、重载赋值运算符函数需警惕L=L;且需释放原有空间;return *this;。
}
bool PriorElem(T e, bool(*eq)(T, T), T &pre_e)const //查找第一个与e满足eq()关系的数据，并用pre_e返回其前驱
{
1、查询表中第一个与e满足eq()关系的数据，并返回其位序。
2、判断该位序是否合法，是则用pre_e返回其前驱，否则返回false。
}
bool NextElem(T e, bool(*eq)(T, T), T &next_e)const //查找第一个与e满足eq()关系的数据，并用pre_e返回其前驱
bool ListInsert(int i, T e) //在位置i处插入新数据e。
{
1、创造两个T型指针，其中一个指向位置i是为q，另一个指向位置末端是为p。
2、for(p依次自减，直到与位置q相等) {p指向的数据依次后移；}
3、位置q指向的数据更换为e。
}
bool ListDelete(int i, T &e) //删除位置i处的数据，并用e返回。
{
1、创造两个T型指针，其中一个指向位置i是为q，另一个指向位置末端是为p。
2、位置q指向的数据赋值给e。
3、for(p依次自减，直到与位置q-1相等) {p指向的数据依次前移；}
}
template<typename T>
void SqList<T>::ListTraverse(void(*visit)(T&))const //类内声明类外定义；函数指针的使用
{函数也可做为另一个的函数参数，但是形参类型需为指针类型，即函数指针。}
friend void MergeList(const SqList<T>&, const SqList<T>&, SqList<T>&);//归并两个有序的顺序表得到新的有序顺序表的算法
{友元函数用于类中，可以访问类中任意成员。
1、创建五个指针； T *pa, *pa_last, *pb, *pb_last, *pc;//pa系列指向线性表La；pb系列指向线性表Lb；pc系列指向线性表Lc
2、将pa和pb指的数据按升序依次赋给pc，直到pa=pa_last或者pb=pb_last
3、判断pa和pb哪一个未指向末端，并将其剩下的值赋给pc指的位置。
}
主程序：
测试一：普通类型
Main1-1.cpp 验证顺序表SqList类的成员函数
测试二：自定义类型
Main1-2.cpp T为用户自定义类型的实例
F1-1.txt 测试文件
测试三：归并算法（友元函数的使用）
Algo1-1.cpp 归并两个有序的顺序表得到新的有序顺序表的算法
顺序线性表类（vector）
测试一：基本类型
Algo1-2.cpp STL中vector使用基本数据类型
测试二：自定义类型
Algo1-3.cpp 在STL中vector使用自定义数据类型
//Algo1-2.cpp STL中向量（顺序线性表）的应用
vector<int>::iterator ip;
vector<int>::const_iterator cip; //vector类中的 const_iterator类 数据成员
a.push_back(i); a.insert(ip, 9); a.erase(a.begin()+4); a.clear(); a.size(); a.capacity(); a.empty();
sort(a.begin(), a.end());
sort(a.begin(), a.end(), greater<int>());//降序排列;仿函数的使用
reverse(a.begin(), a.end());
//Algo1-3.cpp 在STL中vector使用自定义数据类型
bool InputFromFile(ifstream &f, Student &c) //建议使用这种文件输入；而不是下列的重载运算符>>
{
f>>c.name>>c.score;
return f.good();
}
ifstream& operator>>(ifstream &f, Student& c)
{
f>>c.name>>c.score;
return f;
}
ifstream fin("F1-1.txt");
Student e;
while(!fin.eof()) //没有到文件尾
//while(fin.peek != EOF)
{
if(InputFromFile(fin, e)) //也可重载运算符>>;然后 fin>>e;
a.push_back(e);
}
fin.close();
bool cmp(Student a, Student b)
{
return a.score<=b.score;
}
sort(a.begin(), a.end(), cmp); //排序的第二种方式；按cmp()的定义排序
//sort(vector<T>::iterator ip_begin, vector<T>::iterator ip_end, bool (*func)(T a,T b))
//函数cmp 和 仿函数greater<int>() 返回值类型都是 bool型
//cmp 和 仿函数greater<int>() 都只是名字，没有含参数。
特点：插入或删除时操作方便，但不易实现随机查找。
适用于飞机航班的乘客信息表。
头文件：
LNode.h 单链表结点类型结构体
LinkList.h 单链表的类（LinkList类）
//LinkList.h 单链表的类（LinkList类）
int LocateElem(T e, bool(*eq)(T, T))const //查找第一个与e满足关系eq()的数据
{
1、创建一个指针，指向第一个结点。（该链表带有头节点）
LNode<T> *p=Head->next;
2、循环直到找到第一个与e满足关系eq()的数据，或者链表结束
while(p!=NULL)
}
bool PriorElem(T e, bool(*eq)(T, T), T &pre_e)const //返回前驱
{
1、创建两个指针，其中一个指向第一个结点，另一个为q；
LNode<T> *q, *p=Head->next;
2、直到p指到倒数第二个位置或者满足eq();q指向p的下一个位置。
while(p!=NULL && p->next!=NULL) {q=p->next;...}
}
bool NextElem(T e, bool(*eq)(T, T), T &next_e)const //返回后驱
bool ListInsert(int i, T e) //插入
{
1、创建两个指针，其中一个指向头节点，另一个用于保存新建结点
LNode<T> *s, *p=Head;s=new LNode<T>;
2、p指向第i-1个结点；
while(p!=NULL && j<i-1)
3、在第i个结点之前插入e的结点。
}
bool ListDelete(int i, T &e)const //删除
{
1、创建两个指针，其中一个指向头节点，另一个用于指向删除结点，并释放。
LNode<T> *q, *p=Head;
2、p指向第i-1个结点；
while(p->next!=NULL && j<i-1)
3、删除结点
}
主程序：
测试一：基本类型
Main1-3.cpp 验证单链表LinkList类的成员函数
测试二：归并算法（友元函数）
Algo1-4.cpp 归并两个有序链表的算法
头文件：
DLNode.h 双向链表结点类型结构体
DLinkList.h 双向链表的类（DLinkList类）
//DLinkList.h 双向链表的类（DLinkList类）
bool ListInsert(int i, T e)
{
1、创建两个指针，其中一个指向第i-1个结点，另一个用于保存新建结点
DLNode<T> *s,*p=GetElemP(i);
2、在第i个结点之前插入值为e的结点。
}
bool ListDelete(int i, T &e)const
{
1、创建一个指针，指向第i个结点
DLNode<T> *p=GetElemP(i);
2、删除第i个结点。
}
主程序：
测试一：基本类型
Main1-4.cpp 验证双向循环链表DLinkList类的成员函数
链表类（list）：用双向链表实现的。
测试一：基本类型
Algo1-5.cpp STL中表（链表）的应用
测试二：自定义类型
Algo1-6.cpp 在STL的list中使用自定义数据类型排序
//Algo1-5.cpp STL中表（链表）的应用
list<int>::iterator ip;
a.push_back(i); a.push_front(1); advance(ip, 2); a.insert(ip, 9); a.erase(ip); a.remove(1);
a.clear(); a.size(); a.empty(); a.front(); a.back();a.pop_front();a.pop_back();
a.sort();
a.sort(greater<int>());//降序
//Algo1-6.cpp 在STL的list中使用自定义数据类型排序
bool operator <(const Student &a, const Student &b)
{
return a.score<b.score;
}
bool operator >(const Student &a, const Student &b)
{
return a.score>b.score;
}
L.sort();
L.sort(greater<Student>());//降序
特点：顺序存储结构实现链式存储功能。
应用：赫夫曼树
头文件：
StLinkList.h 静态链表的类（StLinkList类）
主程序：
测试一：基本类型
Main1-5.cpp 验证静态链表StLinkList类的成员函数
1、静态链表存储于数组中，但其顺序却像链表一样。
静态链表数组SL中链表头结点位置[0]，备用链表头结点在位置[MAX_SIZE-1]，其余 MAX_SIZE-2 个结点不在链表中就在备用链表中。
2、单链表的结点通过new命令生成，结点被限制在动态存储区这个大范围内。而静态链表的结点被限制在静态数组这个小范围。
3、单链表不用的结点通过delete命令释放，释放后的结点由编译软件管理；而静态链表的删除结点需要自己管理。
4、从备用链表删除结点或向备用链表插入结点都在表头进行，效率高。
操作受限的线性表。
它的基类：线性表类。
STL：栈（stack）、队列（queue）。
逻辑结构：后进先出。
应用：撤销及恢复功能。
栈的抽象基类：AStack.h 栈抽象类的定义
SqStack.h 顺序栈的类（SqStack类）
Func2-1.h 验证栈类成员函数的主程序
Main2-1.cpp 验证顺序栈SqStack类的成员函数
//SqStack.h
T *base,*top; int stacksize; //三个私有数据成员；基址、栈顶指针、栈容量。
bool Push(T e)
{
1、追加存储空间（申请2倍的空间）。2、复制数据（从原空间至新空间）。3、释放原栈空间，给数据成员赋新值。
}
为提高效率，链表表头为栈顶，表尾为栈底。
DLinkStack.h 用双向链表实现链栈的类（DLinkStack类）
Main2-2.cpp 验证链栈DLinkStack类的成员函数
template<typename T>
class DLinkStack:public AStack<T>, public DLinkList<T> //多继承
{
1、由于DLinkStack类继承了DLinkList类，所以直接继承了DLinkList类的私有成员数据，无需额外增加新的数据。
2、其间各函数可通过调用DLinkList类的公有成员函数实现。
}
Algo2-1.cpp STL中栈的应用
//Algo2-1.cpp STL中栈的应用
st.push(n); st.empty(); st.size(); st.top(); st.pop();
描述：
将十进制数转化为n进制数。例，十进制数
1001转化为十六进制数为：3E9
Algo2-2.cpp 将十进制转换为二～十六进制
描述：
求解：
1、(0-12)*((5-3)3+2)/(2+2)
2、-5.5(-(-3/2)*2)
Algo2-3.cpp 算术表达式求值，输入负数要用(0 - 正数)表示
F2-1.txt
F2-2.txt
Algo2-4.cpp 用递归函数求解汉诺塔问题
描述：
PosType.h 二维坐标位置类型结构体及重载的运算符
PosDirect.h 带下一步方向的二维坐标位置类型结构体
Algo2-5.cpp 用递归函数和非递归函数求解迷宫问题
F2-3.txt
描述：
Algo2-6.cpp 用递归函数和非递归函数求解皇后问题
描述：
Algo2-7.cpp 用递归函数和非递归函数求解马踏棋盘问题
逻辑结构：先进先出
应用：打印机任务的排队
AQueue.h 队列抽象类的定义
表头为队头，表尾为队尾；队列类的实现继承了单链表类
LinkQueue.h 链队列的类（LinkQueue类）
Func2-2.h 验证队列类成员函数的主程序
Main2-3.cpp 验证链队列LinkQueue类的成员函数
//LinkQueue.h
private:
LNode<T> *rear; //在继承的基础之上，又自己添加一个私有成员；
1、顺序循环队列
SqQueueCy.h 顺序循环队列类（SqQueueCy类）
Main2-4.cpp 验证顺序循环队列SqQueueCy类的成员函数
//SqQueueCy.h
protected: //4个数据成员
T *base;
int front;
int rear;
int queuesize;
int QueueLength()const //返回队列长度
{
return (rear-front+queuesize)%queuesize; //%queuesize可确保返回值小于queuesize
}
bool EnQueue(T e) //插入队尾元素e
{
1、若队列满，则增加存储容量，复制队列元素。
2、释放原队列空间，重新给数据成员赋值。
3、将e插入队尾。
}
循环队列最大的长度等于
队列空间存储-1
2、顺序队列
SqQueue.h 顺序队列类（队头元素固定在[0]单元）
Main2-5.cpp 验证顺序队列SqQueue类的成员函数
private: //3个数据成员
T *base;
int rear;
int queuesize;
bool DeQueue(T &e) //删除队头元素
{
1、各元素依次后移。
2、数据成员rear自减1；
}
顺序队列类与通常人们排队的方式一样。当元素较多时，时间开销大。
3、顺序不移动队列
SqQueueNM类继承了SqQueueCy类
出队列时不移动元素，但不循环利用原有空间。空间利用率低。
SqQueueNM.h 顺序不移动队列类（出队时不移动元素，只改变头指针的值）
Main2-6.cpp 验证顺序不移动队列SqQueueNM类的成员函数
//SqQueueNM.h 继承了SqQueueCy类的4个保护数据成员。
SqQueueNM(int k):SqQueueCy<T>(k) //调用基类的有参构造函数
{
}
4、双端顺序循环队列
DeQueueCy类继承了SqQueueCy类
在队头与队尾都可以进行插入与删除的数据结构，被称为双端队列。
DeQueueCy.h 双端顺序循环队列类（DeQueueCy类）
Main2-7.cpp 验证双端顺序循环队列DeQueueCy类的成员函数
//DeQueueCy.h 继承了SqQueueCy类，无添加其他数据成员，无构造函数。
bool EnQueueAtFront(T e) //在队头插入元素e
{
1、若队列满，则增加存储容量，复制队列元素。
2、释放原队列空间，重新给数据成员赋值。
3、将e插入队头。
}
Algo2-8.cpp STL中队列的应用
Algo2-9.cpp STL中双端队列的应用
Algo2-10.cpp STL中优先队列的应用
//Algo2-8.cpp STL中队列的应用
queue<int> q;
q.push(n); q.empty(); q.size(); q.pop(); q.front(); q.back();
//Algo2-9.cpp deque
void out(int a)
{
cout<<a<<' ';
}
deque<int> q;
q.push_back(n); q.push_front(n*2); q.front(); q.back(); q.pop_front(); q.pop_back(); q.size()
for_each(q.begin(), q.end(), out); //遍历
//for_each(vector<T>::iterator ip_begin, vector<T>::iterator ip_end, void (*func)(T a))
//Algo2-10.cpp priority_queue
class cmp
{
public:
bool operator()(const PosType a, const PosType b)const //仿函数的定义
{
return a.row>b.row; //按PosType的row域升序排序 在队列中为降序储存，所以出队变成了升序。
// return a.row<b.row; //按PosType的row域降序排序
}
};
struct PosType
{
int row, col;
};
PosType p[]={{3, 4}, {5, 6}, {4, 1}}, q;
priority_queue<PosType, vector<PosType>, cmp> pri_queue; //容器为向量
// priority_queue<PosType, deque<PosType>, cmp> pri_queue;//容器为双端队列
//优先队列的数据类型为PosType；保存数据的容器为vector或deque；cmp为元素的比较方式
//priority_queue内部可能有sort(v.begin(),v.end(),cmp()); //cmp()为仿函数；类似于greater<int>()
pri_queue.push(p[i]); pri_queue.top(); pri_queue.pop();
STL的deque有vector的所有功能；并且可以分块储存，也就是说一个队列的所有元素不必存在一个连续的存储空间。
优先队列priority_queue中的元素入队时插在队尾，出队时按关键字有序出队。可用堆排序实现优先队列。
通过自编比较器类（class cmp）,优先队列类可以实现对任何数据类型按任意的要求做比较。
BankQueue.h 模拟银行队列事件的基类（BankQueue类）
BankN.h 模拟银行多队列排队事件的类（BankN类）
Algo2-11.cpp 银行业务（多队列）模拟
Bank1.h 模拟银行排队机事件的类（Bank1类）
Algo2-12.cpp 银行业务（排队机）模拟
HString.h 字符串的类（HString类）
Main3-1.cpp 验证串HString类的成员函数
{
char operator[](int i)const
{
return ch[i];
}
HString& operator=(const HString &L) //考虑到 L = L;
{
if(this!=&L)
{
if(ch!=NULL)
delete ch;
ch=new char[L.length];
assert(ch!=NULL);
for(int i=0; i<L.length; i++)
ch[i]=L[i];
length=L.length;
}
return *this;
}
void Output( ostream& out )
{
for(int i=0; i<length; i++)
out<<ch[i];
}
};
ostream& operator << (ostream& out, HString& str)
{
str.Output(out);
return out;
}
Algo3-1.cpp STL中的串
//Algo3-1.cpp STL中的串
char c, *p="God bye!", *q="God luck!";
string t, s(p),r("Good luck!"); string u(r);//四种初始化方式
t.assign(p); t.assign("God bye!"); t=s; t="o"; //四种赋值方式
s.compare(t); //比较
i = r.find(t, i+2); //从r的[i+2]起查找t
r.replace(i, 1, s); //将在r中找到的t用s替代
s.erase(); //清空s
t.erase(0, 5); //从串t的[0]起删除5个字符
s=r.substr(5, 4); //串s为：从串r的[5]起4个字符
t.insert(5, s); //在串t的[5]前插入串s
1、朴素的模式匹配算法
2、KMP算法和改进的KMP算法
Algo3-2.cpp KMP和改进的KMP算法
3、Boyer-Moore算法
Algo3-3.cpp 用类实现BM算法的程序
4、Karp-Rabin算法
Algo3-4.cpp Karp-Rabin算法
变长参数表：
Algo3-5.cpp 变长参数表（函数的实参个数可变）编程示例
#include<cstdarg> //用于存取变长参数表
T Max(int num, ...) //返回num个数中的最大值
{
va_list ap; //变长参数表类型
va_start(ap, num); //ap指向固定参数num后面的实参表
m=va_arg(ap, T); //读取ap所指的实参，其类型为T，将其赋给m；ap向后移
va_end(ap); //与va_start()配对，ap不再指向变长参数表
}
任意维数组：
MuArray.h 用vector实现多维数组的类（MuArray类）
Main3-2.cpp 验证多维数组MuArray类的成员函数
//MuArray.h 用vector实现多维数组的类（MuArray类）
private: //一个成员函数，四个数据成员
vector<T> base; //数组元素
int dim; //数组维数
vector<int> bounds; //数组维界
vector<int>constants; //数组映像函数常量基址
bool Locate(va_list ap, int &off)const
//若ap指示的各项下标合法，则求出该元素在base中的相对地址off
{
off+=constants[i]*ind; //相对地址 = 各维的下标值 * 本维的偏移量之和
}
base.assign(elemtotal, 0); //给base分配elemtotal个空间，其值均为0
constants.assign(dim, 1); //给constants分配dim个空间，其值均为1
RLSMatrix.h 三元组行逻辑链接顺序表的类（RLSMatrix类）
Main3-3.cpp 验证稀疏矩阵RLSMatrix类的成员函数
F3-1.txt
F3-2.txt
F3-3.txt
操作受限的线性表。
它的基类：线性表类。
STL：栈（stack）、队列（queue）。
逻辑结构：先进后出。
AVLTNode.h 平衡二叉树的结点类型结构体
AVLTree.h 平衡二叉树的类（AVLTree类）
BiTNode.h 二叉链表结点类型结构体
BiTree.h 二叉链表结构的二叉树类（BiTree类）
BSDTree.h 二叉排序树的删除类（BSDTree类）
BSTree.h 二叉排序树的类（BSTree类）
C4-1.h 对两个数值型关键字的比较约定为如下的宏定义
C4-2.h 设置平衡因子的值（左子树的深度-右子树的深度）
ChangeTree.h 二叉排序树转换操作的类（ChangeTree类）
CSNode.h 孩子-兄弟二叉链表结点类型结构体
CSTree.h 孩子-兄弟二叉链表结构的树或森林类（CSTree类）
F4-1.txt
F4-2.txt
F4-3.txt
F4-4.txt
F4-5.txt
F4-6.txt
F4-7.txt
F4-8.txt
F4-9.txt
F4-10.txt
Func4-1.h 数据类型为基本类型的I/O操作
Func4-2.h 定义数据类型和关键字类型及对它们的I/O操作
Func4-3.h 增加的I/O操作
Func4-4.h 增加的I/O操作
HuffmanNode.h 赫夫曼树结点类型结构体
HuffmanTree.h 赫夫曼树类（HuffmanTree类）
Main4-1.cpp 验证二叉链表结构的二叉树BiTree类的成员函数
Main4-2.cpp 验证三指针链表结构的二叉树PBiTree类的成员函数
Main4-3.cpp 验证二叉链表结构的二叉排序树BSTree类的成员函数
Main4-4.cpp 验证平衡二叉树AVLTree类的成员函数
Main4-5.cpp 验证红黑树RBTree类的成员函数
Main4-6.cpp 验证伸展树SpTree类的成员函数
Main4-7.cpp 验证孩子-兄弟二叉链表结构的树或森林CSTree类的成员函数
Main4-8.cpp 用CSTree类构造森林
Main4-9.cpp 验证赫夫曼树HuffmanTree类的成员函数
PBiTNode.h 三指针链表结点类型结构体
PBiTree.h 三指针链表结构的二叉树类（PBiTree类）
RBTNode.h 红黑树的结点类型结构体
RBTree.h 红黑树的类（RBTree类）
SpTree.h 伸展树的类（SpTree类）
操作受限的线性表。
它的基类：线性表类。
STL：栈（stack）、队列（queue）。
逻辑结构：先进后出。
AdjListGraph.h 图的邻接表类（AdjListGraph类）
Algo5-1.cpp MatrixGraph类对象调用深度优先和广度优先搜索遍历的程序
Algo5-2.cpp AdjListGraph.h类对象调用深度优先和广度优先搜索遍历的程序
Algo5-3.cpp DFST深度优先生成树类将无向图构造为生成森林，并以孩子-兄弟二叉链表存储之
Algo5-4.cpp 构造最小生成树
Algo5-5.cpp 求连通图关节点的算法
Algo5-6.cpp 输出有向图的一个拓扑序列
Algo5-7.cpp 求关键路径
Algo5-8.cpp 迪杰斯特拉算法，从某个源点到其余各顶点的最短路径
Algo5-9.cpp 调用弗洛伊德类求每两点之间的最短路径
Algo5-10.cpp 调用弗洛伊德类求两城市之间最短距离的程序
C5-1.h 对图的两个顶点相等的宏定义和定义权值类型
F5-1.txt
F5-2.txt
F5-3.txt
F5-4.txt
F5-5.txt
F5-6.txt
F5-7.txt
F5-8.txt
F5-9.txt
F5-10.txt
F5-11.txt
F5-12.txt
F5-13.txt
Floyd.h 弗洛伊德最短路径类（Floyd类）
Func5-1.h 定义顶点结构模板的实参V及对其的I/O操作
Func5-2.h 定义MatrixGraph类中弧结构模板的实参A及对其的I/O操作
Func5-3.h 定义一种顶点结构模板的实参V及对其的I/O操作
Func5-4.h 定义一种MatrixGraph类中弧结构模板的实参A及对其的I/O操作
Func5-5.h 定义AdjListGraph类中弧结构模板的实参A及对其的I/O操作
Func5-6.h 定义一种AdjListGraph类中弧结构模板的实参A及对其的I/O操作
Graph.h 图基类的定义
Main5-1.cpp 验证图的邻接矩阵类（MatrixGraph<VerT, ArcT>）的成员函数
Main5-2.cpp 另一种顶点和弧结构体调用邻接矩阵类的成员函数
Main5-3.cpp 验证图的邻接表类（AdjListGraph<VerT, ArcT>）的成员函数
Main5-4.cpp 验证用于自定义顶点和弧结构体的邻接表类的成员函数
Map.txt
MatrixGraph.h 图的邻接矩阵类（MatrixGraph类）
Topo.h 拓扑类（Topo类）
操作受限的线性表。
它的基类：线性表类。
STL：栈（stack）、队列（queue）。
逻辑结构：先进后出。
Algo6-1.cpp 验证SqTable类的成员函数
Algo6-2.cpp 验证HashTable类的成员函数
Algo6-3.cpp 验证BTree类的成员函数
Algo6-4.cpp 验证DLTree类的成员函数
Algo6-5.cpp 验证TrieTree类的成员函数
BTNode.h B树的3种结构体
BTree.h B树类（BTree类）
DLTNode.h 双链键树结点的存储结构
DLTree.h 双链键树类（DLTree类）
F6-1.txt
F6-2.txt
F6-3.txt
F6-4.txt
F6-5.txt
Func6-1.h 定义模板的实参Sc及对其的I/O操作
Func6-2.h 定义模板的实参HD及相应的I/O操作
Func6-3.h 定义模板的实参Record及相应（包括KeyType）的I/O操作
HashTable.h 开地址法哈希表类（HashTable类）
SqTable.h 静态查找表类（SqTable类）
TrieNode.h Trie树结点的存储结构
TrieTree.h Trie树类（TrieTree类）
1、直接插入排序：将待插数据逐一与有序部分的数据作比较，以确定插入位置。
2、折半插入排序：先找出有序部分位于中间的数据，与待插入数据作比较；每比较一次，就可减少一半的比较次数。数据量大时效率高。
3、二路插入排序：先找出有序部分位于中间的数据，与待插入数据作比较；若插在前半部分，则前面的数据向前移，反之，后面的数据向后移。可减少移动次数，但需要一个额外数组。
InsSort.h 插入排序类
Func7-1.h 定义模板的实参ID及相应的I/O操作
Algo7-1.cpp 验证插入排序类
F7-1.txt
Algo7-2.cpp 冒泡排序类
Algo7-3.cpp 简单选择排序类
由直接插入算法改进而来。
Algo7-4.cpp 希尔排序类
快排序的关键在于基准的选择。
Algo7-5.cpp 快速排序类
1、将顺序存储的数据看成是一颗完全二叉树
2、对于大顶堆，确保每棵子树的根节点都是整个子树中的最大值；这就保证了根节点是所有数据中的最大值，但不保证所有数据有序。
Heap.h 堆类
Algo7-6.cpp 堆排序类
优先队列由堆排序类实现。
PriQueue.h 优先队列类
Algo7-7.cpp 验证优先队列类的成员函数
充分利用了把大问题转化成一个个小的子问题的思想。（由迭代或递归来实现）
Algo7-8.cpp 二路归并排序类
Func7-2.h 定义模板的实参Rec及相应的I/O操作
Algo7-9.cpp 用STL实现字符串的基数排序
F7-2.txt
Algo7-10.cpp STL排序算法的应用1
Algo7-11.cpp STL排序算法的应用2
操作受限的线性表。
它的基类：线性表类。
STL：栈（stack）、队列（queue）。
逻辑结构：先进后出。
Algo8-1.cpp
Algo8-2.cpp k路平衡归并类（替代败者树）
Algo8-3.cpp 用优先队列实现置换-选择排序类
F8-1.txt
Func8-1.h 增加的I/O操作