数据结构实训报告(常用版).doc

数据结构实训报告（常用版）
(可以直接使用，可编辑 完整版资料，欢迎下载）
北京联合大学
实训报告

课程（项目）名称： 数据结构
学 院： 专 业：
班 级： 学 号：
姓 名： 成 绩：

2012年　6　月　21　日

数据结构实训任务一
一、任务与目的：
1、用顺序表表示两个无序集合A、B，实现集合的如下操作，求两个集合的并集、交集、差集。
2、 用顺序表表示两个集合A、B（集合A、B都是有序递增的情况）实现集合的如下操作，求两个集合的并集、交集、差集。
3、用带头单链表存储结构表示两个无序集合A、B，实现集合的如下操作，求两个集合的并集、交集、差集。
4、用带头单链表存储结构表示两个集合A、B（集合A、B都是有序递增的情况），实现集合的如下操作，求两个集合的并集、交集、差集。
5、杀人游戏 N个人坐成一圈玩杀人游戏，按顺时针编号 1 2 3 N。从1号开始顺时针开始数到第m号就杀掉第一个人，被杀掉的人要退出游戏。 如果数到了编号的末尾，接着数开头的编号。 重复，直至杀掉一半人时，游戏结束，聪明的你能告诉我活到最后的幸存者最初的编号是多少吗？ 输入数据：N、M ；输出数据：幸存者的编号 分析该程序，如果N=20，M=2，……10。聪明的你应选择的编号是多少，（提示，计算出M分别等于1到10的情况下，那些编号生存概率较大）。给出实验结果
6、作业抽查问题：有35个学生的班级，由于某种原因不能够做到全部检查作业，现在希望每次抽查10名学生，希望能够随机抽查，并能够有记忆，即希望抽查过的学生，下次抽查的概率有所减小，但避免不被抽查。设计一个算法实现该功能，给出你的解释。
1. void BingSet(SqList A, SqList B,SqList &C)
{//求并集
int i,j;
int flag=0;
C.length=0;
for(i=0;i
{flag=LocateElem_Sq(A, B.elem[j]);
if(flag!=0)
{C.elem[i]=B.elem[j];i++;}
}
C.length=i;
}

void ChaSet(SqList A, SqList B,SqList &C)
{//求差集
int i,j,k;
int flag=0;
C.length=0;
k=0;
for(i=0;iem[i];k++;}
}
C.length=k;
}

运行结果：

2. void BingSet(SqList A, SqList B,SqList &C)
{//求并集
int i,j,k;
k=0;
C.length=0;
for(i=0,j=0;(i[i];k++;i++;j++;
}
else
{C.elem[k]=B.elem[j];k++;j++;}
}
}
if(i{//求交集
int i,j,k;
k=0;
C.length=0;
for(i=0,j=0;(i
int i,j,k;
int flag=0;
k=0;
C.length=0;
for(i=0,j=0;(ilem[i];k++;i++;}
}
C.length=k;
}

void InserOrder_Sq(SqList &L,ElemType e)
{int i,j;
for(i=0;i=e)
break;
}
for(j=L.length-1;j>=i;j--)
L.elem[j+1]=L.elem[j];
L.elem[i]=e;
L.length++;
}
运行结果：

3. void bing(link &p,link &h,link &q)
{//求并集
link l,s,m;
int j=0,i=0;
q=new LNode;
q->date=NULL;
q->next=NULL;
s=p->next;
m=q;
while(s)
{l=new LNode;
l->date=s->date;
l->next=NULL;
s=s->next;
m->next=l;
m=l;
s=h->next;
while (s)
{i=s->date;
j=Locate(p,i);
if(j==0)
{l=new LNode
l->date=s->date;
l->next=NULL;
m->next=l;
m=l;
}
s=s->next;}
}
void jiao(link &p,link &h,link &q)
{ //求交集
link l,s,t,m;
int j=0;
Elem i=0;
q=new LNode;
q->date=NULL;
q->next=NULL;
m=q;

s=h->next;
while (s)
{i=s->date;
j=Locate(p,i);
if(j==1)
{l=new LNode;
l->date=s->date;
l->next=NULL;
m->next=l;
m=l;
}
s=s->next;
}
}
void cha(link &p,link &h,link &q)
{//求差集
link l,s,t,m;
int j=0;
Elem i=0;
q=new LNode;
q->date=NULL;
q->next=NULL;
m=q;
s=p->next;
while (s)
{i=s->date;
j=Locate(h,i);
if(j==0)
{l=new LNode;
l->date=s->date;
l->next=NULL;
m->next=l; m=l;}
s=s->next;} }
void shengcheng(link &p,link &h,link &q)
{ int i,j=0;
Elem e;
for(i=0;i<11;)
{if(i==0)
{p=new LNode;
p->date=NULL;
p->next=NULL;
h=p;q=p;i++;}
else
{e=rand()%50+1;
j=Locate(p,e);
if(j==0)
{LInsert(p,e);i++;}}}}
运行结果：

4. void bing(link &p,link &h,link &q)
{ //并集
link l,s,m;
int j=0,i=0;
q=new LNode;
q->date=NULL;
q->next=NULL;
s=p->next;
m=q;
while(s)
{l=new LNode
l->date=s->date;
l->next=NULL;
s=s->next;
m->next=l;
m=l;}
s=h->next;
while (s)
{i=s->date;
j=Locate(p,i);
if(j==0)
{LInsert(q,i);}
s=s->next;} }
void jiao(link &p,link &h,link &q)
{//交集
link l,s,t,m;
int j=0;
Elem i=0;
q=new LNode;
q->date=NULL;
q->next=NULL;
m=q;
s=h->next;
while (s)
{i=s->date;
j=Locate(p,i);
if(j==1)
{l=new LNode;
l->date=s->date;
l->next=NULL;
m->next=l;
m=l;}
s=s->next;} }
void cha(link &p,link &h,link &q)
{//差集
link l,s,t,m;
int j=0;
Elem i=0;
q=new LNode;
q->date=NULL;
q->next=NULL;
m=q;
s=p->next;
while (s)
{i=s->date;
j=Locate(h,i);
if(j==0)
{l=new LNode;
l->date=s->date;
l->next=NULL;
m->next=l;
m=l;}
s=s->next;} }
void shengcheng(link &p,link &h,link &q)
{int i,j=0;
Elem e;
for(i=0;i<11;)
{if(i==0)
{p=new LNode;
p->date=NULL;
p->next=NULL;
h=p;q=p;i++;}
else
{e=rand()%50+1;
j=Locate(p,e);
if(j==0)
{LInsert(p,e);i++;}}}}
运行结果：

5. #include
#include
#include
#define LEN sizeof(struct kill)
//定义struct kill 类型长度
struct kill
{ int num;
struct kill *next; };
struct kill *create(int m)
{struct kill *head,*p1,*p2; int i;
p1=p2=(struct kill*)malloc(LEN);
head=p1;
head->num=1;
for(i=1,p1->num=1;inum=i+1;
p2->next=p1; p2=p1; }
p2->next=head;
return head; }
struct kill *findout(struct kill *start,int n)
{int i;
struct kill *p;
i=n;
p=start;
for(i=1;inext;
return p; }
struct kill *letout(struct kill *last)
{struct kill *out,*next;
out=last->next;
last->next=out->next;
next=out->next
free(out);
return next; }
void main()
{ int m,n,i,servive;
struct kill *p1,*p2;
cout<<"请输入参加杀人游戏总人数m:"<>m;
cout<<"要杀掉的人的序号n:"<>n;
if(n==1)
{ servive=m; }
else
{ p1=p2=create(m);
for(i=1;i2; }
servive=p2->num;
free(p2); }
cout<<"幸存者是："<
#include
#include
using namespace std;//定义结构体
struct Student
{int id; //学生id
int times; //定义学生抽查数};
Student stu[35]; //35个学生
int cho[10]; //抽查的10个学生
int top; //已抽查学生数
int choose()
{int n=rand()%35; //随机抽取
for(int i=0;id main()
{char a='Y';
srand(time(0)); //随机数初始化
int i;for(i=0;i<35;i++)//学生初始化
{stu[i].id=i+1;stu[i].times=0;}
while(a=='Y'||a=='y')
{int tmp;top=0;
for(i=0;i<10;i++) //抽取10个学生
{tmp=choose(); //抽取学生
cho[top++]=tmp;
stu[tmp].times++;
cout<<"第"<p].times))<>a;}}
运行结果：

数据结构实训任务二
一、任务与目的：主要考察的是栈与队列的逻辑结构和存储结构。
1、用栈，判断一个算数表达式中的圆括弧、方括弧和花括弧是否匹配。
2、用栈，把十进制的整数转换为二至九之间的任一进制
3、设计一个算法，检测一个字符串数组是否是回文，回文是指这个字符串是否关于中心对称。int Check（char a[]，int n）
4、采用SPT规则的单机生产计划问题。问题描述如下，存在一台机器要加工n个工件，每个工件i都有一个确定的加工时间 ，采用按照 递增的顺序，进行加工，计算每个工件的完成时间（初始加工时间为0）。设计一个算法，输入工件数量n，随机在[1，30]的区间内产生每个工件的加工时间 。按照SPT规则进行加工，输出每个工件的完成时间。
5、采用EDD规则的单机生产计划问题。问题描述如下，存在一台机器，要加工n个工件，每个工件i都有一个确定的加工时间 ，同时每个工件都有一个确定的交货期 ，采用按照 递增的顺序，进行加工，计算每个工件的完成时间（初始加工时间为0）。设计一个算法，输入工件数量n，随机在[1，30]的区间内产生每个工件的加工时间 ，在区间[2，20*n]内随机产生每个工件的交货期 。按照EDD规则进行加工，输出每个工件的完成时间，计算每个工件i完成时间和 的差值。

1. void Ininstack(stack &s)
{//初始化
s.elem=new stype[SIZE];
s.top=-1;
s.size=SIZE;
s.insize=IN;}
void INsize(stack &s)
{//扩容
stype *a;int i;
a=new stype[s.size+s.insize];
for(i=0;i<=s.top;i++)
a[i]=s.elem[i];
delete []s.elem;
s.elem=a;
s.size+=s.insize;}
void Push(stack &s,stype e)
{ //入栈
if(s.top==(s.size-1))
INsize(s);s.top++;
s.elem[s.top]=e;}
stype Pop(stack &s)
{//出栈
stype e;e=s.elem[s.top];
s.top--;return e;}
stype GetTop(stack s)
{//取栈顶
stype e;e=s.elem[s.top ];
return e;}
void main()
{stype e,t,ch;
stack s;char a[20];
int i=0,n;Ininstack(s);
cout<<"请输入算术表达式(以$结尾):";
while(ch!='$')
{cin>>ch;
a[i]=ch;i++;}
n=i;
for(i=0;i {e=a[i];Push(s,e);}
if(a[i]=='}'||a[i]==']'||a[i==')'])
{t=GetTop(s);
if(a[i]=='}' && t=='{')Pop(s);
else if(a[i]==']' && t=='[')
Pop(s);else if(a[i]==')' && t=='(')
Pop(s);}}
if(s.top==-1)
cout<<"括号匹配!"<ack(stack &s)
{ //初始化
s.elem=new stype[SIZE];s.top=-1;
s.size=SIZE;s.insize=IN;}
void INsize(stack &s)
{ //扩容
stype *a;int i;
a=new stype[s.size+s.insize];
for(i=0;i<=s.top;i++)
a[i]=s.elem[i];
delete []s.elem;
s.elem=a;s.size+=s.insize;}
void Push(stack &s,stype e)
{//入栈
if(s.top==(s.size-1))
INsize(s);s.top++;
s.elem[s.top]=e;}
stype Pop(stack &s)
{ //出栈
stype e;e=s.elem[s.top];s.top--;
return e;}
void main()
{stack s;int a,b;Ininstack(s);
cout<<"请输入任意非负十进制数:";
cin>>a;
cout<<"请输入需要转换的进制数(进制数为二至九)";
cin>>b;
while(a)
{Push(s,a%b);a=a/b;}
while(!(s.top==-1))
cout<stype[s.size+s.insize];
for(i=0;i<=s.top;i++)a[i]=s.elem[i];
delete []s.elem;
s.elem=a;s.size+=s.insize;}
void Push(stack &s,stype e)
{//入栈
if(s.top==(s.size-1))INsize(s);
s.top++;s.elem[s.top]=e;}
void Error(char *a)
{ cout< &s)
{ stype e;e=s.elem[s.top];
s.top--;return e;}
int Check(char a[],int n,stack &s)
{//判断
int i;char e;Pop(s);
for(i=0;itack(s);
cout<<"请输入字符串(以$结尾):";
while(ch!='$')
{cin>>ch; [i]=ch; ush(s,ch); +;}
n=i; Check(a,n,s);
if(t==1)cout<<"是回文!"< a.length=0;
a.listsize=SIZE;
a.incrementsize=INCREMENT;}
void paixu(sqlist a) //排序
{ int i,j,t,m;for(i=0;ia.elem[j+1])
{ t=a.elem[j];m=a.num[j];
a.elem[j]=a.elem[j+1];
a.num[j]=a.num[j+1];
a.elem[j+1]=t;a.num[j+1]=m}}
void shuchu(sqlist &a)
{int i;for(i=0;imtype *num; //序号
elemtype *welem; //完成时间
elemtype *jelem; //交货期
elemtype *celem; //差值
int length; //长度
int listsize; //分配量
int incrementsize; //增补量
}sqlist;
void chushihua(sqlist &a) //初始化
{a.elem=new elemtype[SIZE];
a.num=new elemtype[SIZE];
a.welem=new elemtype[SIZE];
a.celem=new elemtype[SIZE];
a.jelem=new elemtype[SIZE];
a.length=0;
a.listsize=SIZE;
a.incrementsize=INCREMENT;}
void paixu(sqlist a) //排序
{int i,j,t,m,p;
for(i=0;ia.jelem[j+1])
{ t=a.elem[j];
p=a.jelem[j];
m=a.num[j];
a.elem[j]=a.elem[j+1];
a.jelem[j]=a.jelem[j+1];
a.num[j]=a.num[j+1];
a.elem[j+1]=t;
a.jelem[j+1]=p;
a.num[j+1]=m;}}
void shuchu(sqlist &a)
{int i;for(i=0;i[i]=a.jelem[i]-a.welem[i];
cout<式，将其转换为二叉树的链式存储方式。
2、 二叉树的遍历
a) 先序、中序和后序三种形式的链式存储递归式算法
b) 先序、中序和后序三种形式的链式存储非递归式算法
c) 层次遍历的算法。
3、 二叉树一些基本操作
a) 计算二叉树的深度；
b) 计算二叉树的叶子节点个数
c) 计算二叉树的单支节点的个数
d) 计算二叉树的双支节点的个数
4、 编写一个主函数能够测试你所设计的算法。
主函数调用教材创建二叉树的创建教材图7-10的二叉树链式存储方式。
{p=st.a[st.top];
st.top--;
cout<data;
while (p->right!=NULL)
{st.top++;
st.a[st.top]=p->right;
q=p->right;
while (q->left!=NULL)
{st.top++;
st.a[st.top]=q->left;
q=q->left;
}
代码：#include
#include
#include
#define MAXSIZE 20
int d=0;
int l=0;
typedef struct node //二叉树结点的结构体表示形式
{char data;
struct node* left,*right;
}BTree;
typedef BTree *Tree;
typedef struct stackelem //栈的结构体表示形式
{BTree* a[MAXSIZE];
int top;
}Stack;
void CreateBiTree_Rec(Tree &T) //先序创建二叉树的方法
{char ch;
cin>>ch;
if(ch=='#')
T=NULL;
else
{T= new BTree;
T->data=ch;
CreateBiTree_Rec(T->left);
CreateBiTree_Rec(T->right); }}
void Preorder(Tree t) //前序遍历，递归的方法
{if (NULL!=t)
{cout<data;
Preorder(t->left);
Preorder(t->right); }}
void Preorder2(Tree t) //前序遍历的非递归实现
{Tree p;
Stack st;
st.top=-1;
if (NULL==t)
{return; }
else
{st.top++;
st.a[st.top]=t;
while (st.top!=-1)
{p=st.a[st.top];
st.top--;
cout<data;
if (p->right!=NULL)
{st.top++;
st.a[st.top]=p->right; }
if (p->left!=NULL)
{st.top++;
st.a[st.top]=p->left; } }}}
void Inorder(Tree t)
//中序遍历，递归实现
{if (NULL!=t)
{Inorder(t->left);
cout<data;
Inorder(t->right); }}
void Inorder2(Tree t)
//中序遍历，非递归实现
{Tree p,q;
Stack st;
st.top=-1;
if (NULL==t)
{return;
}
else
{while (t!=NULL)
{st.top++;
st.a[st.top]=t;
t=t->left;
}
while (st.top!=-1)
break;
}
}}}
void PostorderTree t)
//后序遍历，递归实现
{if (t!=NULL)
{Postorder(t->left);
Postorder(t->right);
cout<data;
}}
void Postorder2(Tree t)
//后序遍历，非递归实现
{Stack st;
st.top=-1;
Tree m;
int flag;
do
{while (t!=NULL)
{st.top++;
st.a[st.top]=t;
t=t->left;
}
m=NULL;
flag=1;
wh