模板实例Word下载.docx
《模板实例Word下载.docx》由会员分享，可在线阅读，更多相关《模板实例Word下载.docx（16页珍藏版）》请在冰点文库上搜索。
Max（Tthefirst,Tthesecond,Tthethird）:
item1（thefirst）,item2（thesecond）,item3（thethird）
{
voidMax<
SetItem（Tthefirst,Tthesecond,Tthethird）
item1=thefirst;
item2=thesecond;
item3=thethird;
TMax<
GetMaxItem（）
Tmaxitem;
maxitem=item1>
item2?
item1:
item2;
maxitem=maxitem>
item3?
maxitem:
returnmaxitem;
Max<
int>
nmyMax（1,2,3）;
double>
dblmyMax（1.2,1.3,-1.4）;
nmyMax.GetMaxItem（）<
dblmyMax.GetMaxItem（）<
或者
template<
classMax//声明类模板Max
voidMax<
TMax<
#include<
iostream>
usingnamespacestd;
//首先看结点组织，采用结点类，凡与结点数据和指针操作有关函数作为成员函数
classList;
classNode{
Tinfo;
//数据域
Node<
*link;
//指针域
public:
Node（）;
//生成头结点的构造函数
Node（constT&
data）;
//生成一般结点的构造函数
voidInsertAfter（Node<
*P）;
//在当前结点后插入一个结点
*RemoveAfter（）;
//删除当前结点的后继结点，返回该结点备用
friendclassList<
;
//以List为友元类，List可直接访问Node的私有成员，与结构一样方便，但更安全
};
Node（）{link=NULL;
Node（constT&
data）{
info=data;
link=NULL;
voidNode<
InsertAfter（Node<
*p）{
p->
link=link;
link=p;
Node<
*Node<
RemoveAfter（）{
*tempP=link;
if（link==NULL）tempP=NULL;
//已在链尾,后面无结点
elselink=tempP->
link;
returntempP;
//再定义链表类，选择常用操作：
包括建立有序链表、搜索遍历、插入、删除、取数据等
classList{
*head,*tail;
//链表头指针和尾指针
List（）;
//构造函数，生成头结点（空链表）
~List（）;
//析构函数
voidMakeEmpty（）;
//清空一个链表，只余表头结点
*Find（Tdata）;
//搜索数据域与data相同的结点，返回该结点的地址
intLength（）;
//计算单链表长度
voidPrintList（）;
//打印链表的数据域
voidInsertFront（Node<
*p）;
//可用来向前生成链表，在表头插入一个结点
voidInsertRear（Node<
//可用来向后生成链表，在表尾添加一个结点
voidInsertOrder（Node<
*p）;
//按升序生成链表
*CreatNode（Tdata）;
//创建一个结点（孤立结点）
*DeleteNode（Node<
//删除指定结点
List<
List（）{
head=tail=newNode<
（）;
~List（）{
MakeEmpty（）;
deletehead;
voidList<
MakeEmpty（）{
*tempP;
while（head->
link!
=NULL）{
tempP=head->
head->
link=tempP->
//把头结点后的第一个节点从链中脱离
deletetempP;
//删除（释放）脱离下来的结点
}
tail=head;
//表头指针与表尾指针均指向表头结点，表示空链
*List<
Find（Tdata）{
*tempP=head->
while（tempP!
=NULL&
&
tempP->
info!
=data）tempP=tempP->
//搜索成功返回该结点地址，不成功返回NULL
intList<
Length（）{
*tempP=head->
intcount=0;
tempP=tempP->
count++;
returncount;
PrintList（）{
cout<
info<
'
\t'
InsertFront（Node<
*p）{
link=head->
head->
link=p;
if（tail==head）tail=p;
InsertRear（Node<
link=tail->
tail->
tail=p;
InsertOrder（Node<
link,*tempQ=head;
//tempQ指向tempP前面的一个节点
if（p->
info）break;
//找第一个比插入结点大的结点，由tempP指向
tempQ=tempP;
tempQ->
InsertAfter（p）;
//插在tempP指向结点之前，tempQ之后
if（tail==tempQ）tail=tempQ->
CreatNode（Tdata）{//建立新节点
*tempP=newNode<
（data）;
DeleteNode（Node<
*tempP=head;
while（tempP->
=p）tempP=tempP->
if（tempP->
link==tail）tail=tempP;
returntempP->
RemoveAfter（）;
//本函数所用方法可省一个工作指针，与InsertOrder比较
intmain（）{
*P1;
List<
list1,list2;
inta[16],i,j;
请输入16个整数"
for（i=0;
i<
16;
i++）cin>
>
a[i];
//随机输入16个整数
i++）{
P1=list1.CreatNode（a[i]）;
list1.InsertFront（P1）;
//向前生成list1
P1=list2.CreatNode（a[i]）;
list2.InsertRear（P1）;
//向后生成list2
list1.PrintList（）;
list1长度：
list1.Length（）<
list2.PrintList（）;
请输入一个要求删除的整数"
cin>
j;
P1=list1.Find（j）;
if（P1!
P1=list1.DeleteNode（P1）;
deleteP1;
list1.PrintList（）;
elsecout<
未找到"
list1.MakeEmpty（）;
//清空list1
list1.InsertOrder（P1）;
//升序创建list1
return0;
vector<
a（n）;
//按需创建
b（10,1）;
//10个元素赋全１，灵活的初始化
c（b）;
//整体拷贝创建
f（t,t+5）;
//异类拷贝创建
迭代器定义：
Vector
iterator
it；
It为定义的迭代器，为指针类型；
b．begin（）;
迭代器指向第一个元素位置；
b．end（）;
迭代器指向最后一个元素的后一个位置；
b．size（）;
求得向量里的元素数；
d（b.begin（）,b.begin（）+3）;
//局部拷贝创建d为b的前３个元素
a.assign（100）;
//动态扩容至100个元素
a.assign（b.begin（）,b.begin（）+3）;
//b的前3个元素赋给a
a.assign（4,2）;
//a向量含4个元素，全初始化为2
intx=a.back（）;
//a的最后一个元素赋给变量x
a.clear（）;
//a向量清空（不再有元素）
if（a.empty（））cout<
”empty”;
//a判空操作
inty=a.front（）;
//a的第一个元素赋给变量y
a.pop_back（）;
//删除a的最后一个元素
a.push_back（5）;
//a最后插入一个元素，其值为5
a.resize（10）;
//a元素个数调至10。
多删少补，其值随机
a.resize（10,2）;
//a元素个数调至10。
多删少补，新添元素初值为2
if（a==b）cout<
”equal”;
//a与b的向量比较操作
1.基本操作
vector是向量类型，她是一种对象实体，具有值，所以可以看作是变量。
她可以容纳许多其他类型的相同实体，
如若干个整数，所以称其为容器。
Vector是C++STL（标准模板类库）的重要一员，使用她时，只要包括头文件#include<
vector>
即可。
vector可以有四种定义方式：
是模板形式，尖括号中为元素类型名，她可以是任何合法的数据类型。
（1）vector<
a（10）;
//定义了10个整数元素的向量，但并没有给出初值，因此其值是不确定的。
（2）vector<
b（10,1）;
//定义了10个整数元素的向量，且给出每个元素的初值为1。
这种形式是数组望尘莫及的，
//数组只能通过循环来成批的赋给相同初值。
（3）vector<
//用另一个现成的向量来创建一个向量。
（4）vector<
d（b.begin（）,b.begin（）+3）;
//定义了其值依次为b向量中第0到第2个（共3个）元素的向量。
因此，创建向量时，不但可以整体向量复制性赋值，还可以选择其他容器的部分元素来定义向量和赋值。
特别的，向量还可以从数组获得初值。
例如：
inta[8]={2007,9,24,2008,10,14,10,5};
va（a,a+8）;
上面第（4）种形式的b.begin（）、b.end（）是表示向量的起始元素位置和最后一个元素之外的元素位置。
向量元素位置也属于一种类型，称为遍历器。
遍历器不单表示元素位置，还可以在容器中前后挪动。
每种容器都有对应的遍历器。
向量中的遍历器类型为：
iterator
因此要输入向量中所有元素，可以有两种循环控制方式：
for（inti=0;
i<
a.size（）;
++i）//第一种方法
a[i]<
for（vector<
iteratorit=a.begin（）;
it!
=a.end（）;
++it）//第二种方法
*it<
第一种方法是下标方式，a[i]是向量元素操作，这种形式和数组一样；
第二种方法是遍历器方式，*it是指针间访形式，它的意义是it所指向的元素值。
a.size（）是向量中元素的个数，a.begin（）表示向量的第一个元素，这种操作方式是一个对象捆绑一个函数调用，
表示对该对象进行某个操作。
类似这样的使用方式称为调用对象a的成员函数，这在对象化程序设计中很普遍。
向量中的操作都是通过使用成员函数来完成的。
它的常用操作有：
//b向量的0~2元素构成向量赋给a
//使a向量只含0~3元素，且赋值为2
intx=a.back（）;
//将a的最后一个向量元素值赋给整数型变量x
//a向量中元素清空（不再有元素）
empty"
//a.empty（）经常作为条件，判断向量是否为空
inty=a.front（）;
//将a的第一个向量元素值赋给整型变量y
//删除a向量的最后一个元素
//在a向量最后插入一个元素，其值为5
//将向量元素个数调至10个。
多则删，少则补，其值随机
//将向量元素个数调至10个。
多则删，少则补，其值为2
if（a=b）cout<
epual"
//向量的比较操作还有!
=,<
<
=,
>
=
除此之外，还有元素的插入与删除、保留元素个数、容量观察等操作。
用STLvector来创建二维数组
通常情况下，采用向量创建二维数组的方法有两种：
方法一：
1introw=3;
//行数
2intcolumn=4;
//列数
3vector<
>
arry2（row）;
//定义一个三行四列的数组
4for（inti=0;
arry2.size（）;
i++）
5{
6arry2[i].resize（column）;
7}
方法二：
arry2（row,vector<
（column））;
algorithm>
boolcmp（inta,intb）;
inti;
vector<
a;
for（i=1;
=10;
a.push_back（i）;
vector<
iteratorit;
for（it=a.begin（）;
it!
it++）
*it;
intx=a.back（）;
x<
c（a）;
inty=c.front（）;
y<
a.pop_back（）;
a.resize（12）;
a.resize（15,2）;
c.clear（）;
if（c.empty（））
向量已为空！
\n"
d（a.begin（）,a.begin（）+5）;
for（it=d.begin（）;
=d.end（）;
s
升级会员 