西南交通大学信息学院研究生中期筛选C++程序.docx
《西南交通大学信息学院研究生中期筛选C++程序.docx》由会员分享，可在线阅读，更多相关《西南交通大学信息学院研究生中期筛选C++程序.docx（60页珍藏版）》请在冰点文库上搜索。
西南交通大学信息学院研究生中期筛选C++程序
2007二编写程序或者程序段
2、实现描述超市的类Suppermarket类，记录系统中现有商品（用链表实现），定义：
初始化链表的构造函数
增加商品的函数Append；
删除商品的函数Delete；
查询商品的函数Query，并显示查询结果
其中，商品具有Id，名称Name，价格Price和数量Number等特性。
//商品72
#include
structGoods
{
doubleId;
char*Name;
floatPrice;
intNumber;
Goods*next;
};
classSupermarket
{
public:
Goods*L;
Supermarket（）;
voidAppend（doubleid,char*name,floatprice,intnumber）;
voidDelete（doublei）;
Goods*query（doublei）
{
Goods*r;
r=L->next;
while（r）
{
if（r->Id==i）
{
cout<<"GoodsID:
"<Id<cout<<"Name:
"<Name<cout<<"Price:
"<Price<cout<<"Number:
"<Number<returnr;
}
r=r->next;
}
cout<<"Nogoodsfound!
"<}
};
Supermarket:
:
Supermarket（）
{
L=newGoods;
L->next=NULL;
}
voidSupermarket:
:
Append（doubleid,char*name,floatprice,intnumber）
{
Goods*r=L;
Goods*p;
while（r->next!
=NULL）
{
r=r->next;
}
p=newGoods;
p->Id=id;
p->Name=name;
p->Price=price;
p->Number=number;
p->next=NULL;//将添加的商品放在最后面
r->next=p;
}
voidSupermarket:
:
Delete（doublei）
{
Goods*p,*r;
p=L;//头指针
r=L->next;
while（r!
=NULL）
{
if（r->Id==i）break;
p=r;r=r->next;
}
if（r==NULL）
{
cout<<"goodsdonitexits"<}
p->next=r->next;//删除了商品
deleter;
}
voidmain（）
{
Supermarkets;
s.Append（1,"apple",5.7,10）;
s.Append（2,"meat",9.8,5）;
s.Append（3,"milk",2.7,8）;
s.query
（1）;
s.query
（2）;
s.query（3）;
s.Delete
（1）;
s.query
（2）;
}
运行结果：
GoodsID:
1
Name:
apple
Price:
5.7
Number:
10
GoodsID:
2
Name:
meat
Price:
9.8
Number:
5
GoodsID:
3
Name:
milk
Price:
2.7
Number:
8
GoodsID:
2
Name:
meat
Price:
9.8
Number:
5
Pressanykeytocontinue
06二、2
假定居民的基本数据包括身份证号，姓名，性别和出生日期，而居民中的成年人又多出两项数据：
最高学历和职业，成年中的党员又多出一项数据：
党派类别，现要求建立三个类，让成年人继承居民类，党员类继承成年人类，并要求每个类中都提供有数据添加，数据删除，数据输出的功能。
//商品72
#include
classPerson
{
public:
Person（）{}
Person（char*id,char*name,charsex,char*birthday）
{
Id=id;
Name=name;
Sex=sex;
Birthday=birthday;
}
voidAdd（char*id,char*name,charsex,char*birthday）
{
Id=id;
Name=name;
Sex=sex;
Birthday=birthday;
}
voidDelete（）
{
Id="";
Name="";
Sex='\0';
Birthday="";
}
voidShow（）
{
cout<<"Id:
"<cout<<"Name:
"<cout<<"Sex:
"<cout<<"Birthday:
"<}
private:
char*Id;
char*Name;
charSex;
char*Birthday;
};
classAdult:
publicPerson
{
public:
Adult（）{}
Adult（char*id,char*name,charsex,char*birthday,char*edu,char*Occ）:
Person（id,name,sex,birthday）
{
Education=edu;
Occupation=Occ;
}
voidAdd（char*id,char*name,charsex,char*Birthday,char*edu,char*Occ）
{
Person:
:
Add（id,name,sex,Birthday）;
Education=edu;
Occupation=Occ;
}
voidDelete（）
{
Person:
:
Delete（）;
Education="";
Occupation="";
}
voidShow（）
{
Person:
:
Show（）;
cout<<"Education:
"<cout<<"Occupation:
"<}
private:
char*Education;
char*Occupation;
};
classPartyMember:
publicAdult
{
public:
PartyMember（）{}
PartyMember（char*id,char*name,charsex,char*Birthday,char*Edu,char*Occ,char*cate）:
Adult（id,name,sex,Birthday,Edu,Occ）
{
category=cate;
}
voidAdd（char*id,char*name,charsex,char*Birthday,char*cate）
{
Person:
:
Add（id,name,sex,Birthday）;
category=cate;
}
voidDelete（）
{
Person:
:
Delete（）;
category="";
}
voidShow（）
{
Person:
:
Show（）;
cout<<"Category:
"<}
private:
char*category;
};
voidmain（）
{
Personp1;
Adulta1;
PartyMemberpm1;
p1.Add（"11041062","Liming",'m',"19881112"）;
p1.Show（）;
p1.Delete（）;
p1.Show（）;
cout<a1.Add（"11041063","Liyan",'f',"19881002","graduate","monitor"）;
a1.Show（）;
a1.Delete（）;
a1.Show（）;
cout<pm1.Add（"11041063","Liyan",'f',"19881002","Party"）;
pm1.Show（）;
pm1.Delete（）;
pm1.Show（）;
cout<}
运行结果：
2005二
1、
编写一个函数，求集合的并集运算，假设两个集合A和Ｂ是递增有序的线性链表ＬＡ和ＬＢ
结果链表用ＬＡ表示，ＬＢ没有保存的必要*/
typedefstructNode
{
intdata;
structNode*next;
}Node;
voidu_add（Node*LA,Node*LB）
{
Node*temp,*temp1,*head,*p;
p=head->next;
while（p）
{
if（LB->datadata）
{
head=LB->next;
temp->next=LA;
temp1->next=LB;
LB->next=temp->next;
}
elseif（LB->data==LA->data）
{
head=LB->next;
}
else
{
temp1=LA;
LA=LA->next;
}
LB=head;
}
}
2、定义一个串类，在串上的操作包括：
判断串是否为空；
求串长；
删除串中从i开始的第k个字符；
将串中小写变大写；
将串中大写变小写；
#include
#include
#include
classsstring
{
public:
sstring（）{s=NULL;}
boolisempty（）
{
if（（*s）!
='\0'）
{
cout<<"ThisStringisnotempty."<returntrue;
}
}
intlength（）;//求长度
voiddel_k（inti,intk）;//删除串中从i开始的第k个字符
voidupper（）;//小写变大写
voidlower（）;//大写变小写
char*s;
};
intsstring:
:
length（）
{
intn=0;
char*temp=s;
while（（*temp）!
='\0'）{
n++;
temp++;
}
returnn;
cout<<"Thelengthofthisstringis"<}
voidsstring:
:
del_k（inti,intk）
{
intj;
intleg=length（）;
for（j=i+k;js[j-k]=s[j];
cout<<"ThenewStringis"<}
voidsstring:
:
lower（）//大写变成小写
{
char*temp=s;
intleg=length（）;
for（inti=0;i{
if（*temp>='A'&&*temp<='Z'）
{
（*temp）+=32;
}
temp++;
}
cout<<"ThenewStringis"<}
voidsstring:
:
upper（）//大写变成小写
{
char*temp=s;
intleg=length（）;
for（inti=0;i{
if（*temp>='a'&&*temp<='z'）
{
（*temp）-=32;
}
temp++;
}
cout<<"ThenewStringis"<}
intmain（）
{
sstringr;
charstr[]="asdsaksKKDJHJ";
printf（"%s\n",str）;
r.s=str;
r.isempty（）;
r.length（）;
r.del_k（2,2）;
r.lower（）;
r.upper（）;
}
运行结果：
asdsaksKKDJHJ
ThisStringisnotempty.
ThenewStringisasaksKKDJHJHJ
ThenewStringisasakskkdjhjhj
ThenewStringisASAKSKKDJHJHJ
Pressanykeytocontinue
3、定义一个栈类，与栈有关的操作包括：
栈初始化；
判栈空；
出栈操作；
入栈操作；
取栈元素；
假定栈元素为整型。
注：
栈的实现可以采用顺序结构，也可以采用链表结构，要求接口与存储结构无关。
方法一、用链表实现
#include
typedefinttype;
structStackNode{
typeelement;
StackNode*previous;
StackNode*next;
};
classStack
{
public:
enum{MaxStack=5};
Stack（）
{
head=newStackNode;
head->element=0;
head->previous=NULL;
head->next=NULL;
top=head;
}
voidpush（typen）
{
if（isFull（））{errMsg（"***TheStackisFull!
***"）;return;}
StackNode*p;
p=top;
top=newStackNode;
p->next=top;
top->element=n;
top->previous=p;
top->next=NULL;
}
typepop（）
{
if（isEmpty（））{errMsg（"***TheStackisEmpty!
***"）;returndummy_val;}
typen;
StackNode*p;
p=top;
n=p->element;
top=p->previous;
deletep;
returnn;
}
boolisEmpty（）{returntop==head;}
boolisFull（）{returnhead->element>MaxStack;}
voidprtypeStack（）
{
if（isEmpty（））{errMsg（"***TheStackisEmpty!
***"）;return;}
StackNode*p;
p=top;
cout<<"Stackcontents,toptobutton";
while（p!
=head）
{cout<<'\n'<element<<"\t";
p=p->previous;
}
}
private:
voiderrMsg（char*msg）{cout<StackNode*head;
StackNode*top;
typedummy_val;
};
voidmain（）
{
Stacks;
typea,b;
cout<<"Pleaseinputatwointnumber.\n";
cin>>a>>b;
s.push（a）;
s.push（b）;
s.prtypeStack（）;
cout<<"\npop:
"<s.prtypeStack（）;
//system（"Pause"）;
}方法二、采用顺序结构
#ifndefstack_class//如果没定义stack_class，
#definestack_class//那么现在开始定义stack_class
#include"iostream.h"
#include"stdlib.h"
constintstack_size=50;//栈中元素最大个数
template//模板T表示一个类
classstack{
private:
inttop;
Tstacklist[stack_size];
public:
stack（void）;
voidpush（constT&item）;//入栈
Tpop（void）;//出栈
voidclearstack（void）;//清栈
Tpeek（void）const;//返回栈顶的元素
intempty（void）;//判断栈空
intfull（void）;//判断栈满
};
//构造stack函数
template//对于模板类，在每一个申明和函数定义都得写这句话
stack:
:
stack（void）:
top（-1）
{
}
//入栈
template//对于模板类，在每一个申明和函数定义都得写这句话
voidstack:
:
push（constT&item）
{
if（top==stack_size-1）
{
cout<<"stackoverflow!
"<exit
（1）;
}
top--;
stacklist[top]=item;
}
//出栈
template//对于模板类，在每一个申明和函数定义都得写这句话
Tstack:
:
pop（void）
{
Ttemp;
if（top==-1）
{
cout<<"栈空了!
"<exit
（1）;
}
temp=stacklist[top];
top++;
returntemp;//返回栈顶元素
}
//访问栈顶元素
template//对于模板类，在每一个申明和函数定义都得写这句话
Tstack:
:
peek（void）const
{
if（top==-1）
{
cout<<"栈空了!
"<exit
（1）;
}
returnstacklist[top];//返回栈顶元素
}
//判断栈空
template
intstack:
:
empty（void）
{
returntop=-1;
}
//判断栈满
template
intstack:
:
full（void）
{
returntop=stack_size-1;
}
//清空栈
template
voidstack:
:
clearstack（void）
{
top=-1;
}
#endifstack_class//结束定义
intmain（）
{
stacksta（123）;
return0;
}
2003一
1、/*本程序从键盘读入整数，并将按从大到小的顺序输入整数中互不相等的那些整数。
程序一边读入整数，一边构造一个从大到小顺序连接的链表，直至不能从键盘读入
整数，然后顺序输出链表上各表元的整数值。
主函数每读入一个整数，就调用函数Insert，
函数Insert将还未出现在链表上的整数按从大到小的顺序插入到链表中。
为了插入方便，链表在表首有一个辅助接点。
*/
#include"stdio.h"
#include"stdlib.h"
typedefstructnode{intval;structnode*next;}NODE;
voidInsert（NODE*list,intx）
{
NODE*u,*v,*p;
inti=0;
u=list;
v=u->next;
while（v&&xval）//位置【1】寻找插入的位置
{
u=v;
v=v->next;
}
if（v==NULL||x>v->val）//位置【2】判断是否要插入新表元
{
p=（NODE*）malloc（sizeof（NODE））;
p->val=x;
p->next=v;//位置【3】
u->next=p;//位置【4】
i++;//i是用来观察函数
}
}
voidmain（）
{
intx;
NODE*head,*p;
//首先建立只有辅助节点的空链表
head=（NODE*）malloc（sizeof（NODE））;
head->next=NULL;//位置【5】
printf（"enterintegers:
"）;
while（scanf（"%d",&x）==1）
Insert（head,x）;
for（p=head->next;p;p=p->next）
printf（"%5d",p->val）;
printf（"\n"）;
}
2、计算并求出K！
的阶乘。
//计算k的阶乘，因为数字太大，所以按位存储在a数组中，且按倒序存储
#include"stdio.h"
#defineMAXN1000
inta[MAXN],b[MAXN];
voidpnext（intk,int*cp）
{
intc=*cp,i,m,r;
for（i=0;i
升级会员 