数据结构上机操作实验报告

实验一单链表的基本操作（必做）

一、实验目的

1.掌握单链表的存储、初始化、插入、删除等操作的程序实现。

2.加深对单链表基本概念,基本理论及相应算法的掌握与理解。

3.了解链表的处理方式，学习体会简单的单链表程序实现相关知识。

二、实验内容

1.建立一个链表、设计链表的基本操作实现算法、输出一个链表表，调试并输出结果。

2.编写一个程序实现如下功能：让计算机产生出50个0~9之间的随机数并依次保存到单链表中;输出遍历单链表；从单链表中删除与给定值相等的所有结点；输出遍历单链表；输出单链表长度，调试并输出结果。

三、实验步骤

1.定义一个链表结构体。。

2.利用插入功能插入一个结点。

3.利用删除功能删除一个结点。

四、程序运行测试

1.利用插入功能插入一个结点。

2.利用删除功能删除一个结点。

五、实验报告要求

1.绘制链表操作实现的流程图。

2.详细给出程序运行测试结果（包括测试数据和测试结果）。

3.选试验步骤2-3中的任意一个，给出程序的详细注释。

4.参考程序中某一部分功能的改进（选做）

5.实验心得与体会

6.附录，实验用源程序

六、参考源代码

#include

#include

typedef struct LNode

{int data;

struct LNode *next;

}Lnode, *LinkList;

//假设下面的单链表均为带头结点。

void CreatLinkList(LinkList &L,int j)

{//建立一个单链表L,数据为整数，数据由键盘随机输入。

LinkList p,q;

L=(LinkList )malloc(sizeof(Lnode));

L->next=NULL;

q=L;

cout<<"在单链表内输入整数："<

for(int i=0;i>p->data;

p->next=q->next;

q->next=p;

q=p; }

int PrintLinkList(LinkList &L)

{//输出单链表L的数据元素

LinkList p;

p=L->next;

if(L->next==NULL)

{cout<<"链表没有元素!"<

return 0;}

cout<<"单链表的数据元素为:";while(p){

cout<data<<" ";

p=p->next;}cout<

return 1;}

void LinkListLengh(LinkList &L)

{//计算单链表L的数据元素个数。

int i=0;

LinkList p;

p=L->next;

while(p)

{ i++;

p=p->next; }

cout<<"单链表的数据元素个数为:"<

int InsertLinkList(LinkList &L, int i, int x) {//在单链表L的第I个元素前插入一个数据元素X。

LinkList p,s;

int j=0;

p=L;

while(p&&j

{p=p->next;

++j;}

if(!p||j>i-1){

cout<<"插入元素的位置不合理!";

return 0;}

s=(LinkList)malloc(sizeof(LNode));

s->data=x;

s->next=p->next;

p->next=s;

return 1;}

int DeleteLinkList(LinkList &L,int i)

{//删除单链表L的第I个数据元素。

LinkList p,q;

int j=0;

p=L;

while(p->next&&j

p=p->next;

++j;}

if(!(p->next)||j>i-1)

{cout<<"删除元素的位置不合理!";

return 0;

}q=p->next;

p->next=q->next;

i=q->data;

free(q);

return 1;

}

void ClearLinkList(LinkList &L)

{//将单链表L置为空表。

L->next=NULL;

}

void DestroyLinkList(LinkList &L)

{//销毁单链表L。

LinkList p,q;

p=L->next;

while(L->next!=NULL)

{q=p->next;

L->next=q;

free(p);p=q;

}free(L);

cout<<"链表已经被销毁!"<

void main()

{//调用上面的各函数，运行并检验程序是否正确。

LinkList L;

int i,j,x;

cout<<"---------------------------------------"<

cout<<" 《单链表实验，按提示操作》"<

cout<<"---------------------------------------"<

cout<<"输入的元素的个数:";

cin>>j;

CreatLinkList(L,j);

LinkListLengh(L);

PrintLinkList(L);

cout<<"在第几个元素前插入:";

cin>>i;

cout<<"输入插入的元素:";

cin>>x;

InsertLinkList(L,i,x);

LinkListLengh(L);

PrintLinkList(L);

cout<<"输入删除元素的位置:";

cin>>i;

DeleteLinkList(L,i);

LinkListLengh(L);

PrintLinkList(L);

ClearLinkList(L);

cout<<"清空链表后:"<

LinkListLengh(L);

PrintLinkList(L);

DestroyLinkList(L);

}

头文件h文件

#include

#include

typedef int ElemType; //规定元素类型为整

struct LNode //定义单链表结构

{

ElemType data;

LNode *next;

}; //初始化单链表

void InitList(LNode *& HL)

{

HL=NULL; //将单链表置空

}

void InsertRear(LNode *&HL,const ElemType & item)

{

LNode *newptr;

newptr=new LNode; //为保存新元素分配动态结点， newptr指向这个结点。

if(newptr==NULL) //若未分配到结点，则停止插入，退出程序运行。

{cerr<<"Memory allocation failare!"<

exit(1); }

newptr->data=item; //把新元素赋给动态结点*newptr的值域

newptr->next=NULL; //给动态结点的指针域置空

if(HL==NULL)

HL=newptr; //向空表插入的结点为表头结点

else{

LNode *p=HL;

while(p->next!=NULL) //从表头开始遍历到最后一个结点为止

p=p->next;

p->next=newptr; //把新结点链接到表尾

}}

void TraverseList(LNode *&HL)

{ LNode *p=HL;

while(p!=NULL)

{cout<data<<" ";

p=p->next; }

cout<

}int ListSize(LNode *&HL)

{ LNode *p=HL;

int i=0; //用来统计结点的个数

while(p!=NULL) //遍历单链表，统计结点数

{ i++;

p=p->next; }

return i;

}int Delete(LNode *&HL,const ElemType & item)

{if(HL==NULL){

cerr<<"HL is NULL!"<

return 0;}

LNode *ap,*cp;

ap=NULL;cp=HL;

while(cp!=NULL)

if(cp->data==item)

break;

else //使前驱指针和当前指针均指向下一个结点

{ap=cp;

cp=cp->next;}

if(cp==NULL){

cerr<<"Deleted element is not exist!"<

return 0;

}

if(ap==NULL) //由cp指向的被删除结点是表头结点

HL=HL->next;

else //由cp指向被删除结点是非表头结点

ap->next=cp->next;

delete cp;

return 1;

}

Cpp文件

#include

#include

typedef int ElemType; //规定元素类型为整

#include "link.h" //此文件中保存有线性表操作在单链表（由动态独立节点构成）上的实现

void main()

{ //构成单链表

LNode *head;

InitList(head);

int i,j;

for(i=0;i<50;i++)

{ j=rand()%10;

InsertRear(head,j);

} //输出遍历单链表

TraverseList(head);

//从单链表中删除与键盘上输入的值相等的所有结点

cout<<"输入一个0~10之间的一个整数：";

cin>>j;

while(Delete(head,j)){} //输出遍历单链表

TraverseList(head); //输出单链表长度

cout<

实验二链表的应用—飞机票销售系统（选做）

一、实验目的

1.掌握单链表的存储。

2.掌握单链表的插入、删除、查找等操作的程序实现。

3.加深对单链表基本概念,基本理论及相应算法的掌握与理解。

二、实验内容

编制一个简单的飞机票销售系统，它可以完成售票，退票，飞机票剩余情况查询等功能。每张飞机票包含机次，座位信息。在售票，退票，查询剩余票等环节中都会显示出飞机票的信息。

三、实验步骤

1.为每张飞机票建立一个结点。

2.利用插入功能插入一个结点（买票）。

3.利用删除功能删除一个结点（卖票）。

4.查找功能查找链表中的结点信息。

四、程序运行测试

1.利用插入功能插入一个结点（买票）。

2.利用删除功能删除一个结点（卖票）。

3.查找功能查找链表中的结点信息。

五、实验报告要求

1.绘制飞机票销售系统实现的流程图。

2.详细给出程序运行测试结果（包括测试数据和测试结果）。

3.选试验步骤2-4中的任意一个，给出程序的详细注释。

4.参考程序中某一部分功能的改进（选做）

5.实验心得与体会

6.附录，实验用源程序

六、参考源代码

#include

#include

#include

#define null 0

#define elemtype int

typedef struct node /*定义个结构*/

{

char num[4]; /*机次*/

elemtype seat; /*座位号*/

struct node *next;

}ticket;

ticket *sale,*back; /*sale为售票链表指针，back为备份链表指针*/ int count() /*查询飞机票剩余情况模块*/

{

ticket *q;

int n=0; /*机票计数器*/

q=sale;

while(q) /*统计机票数*/

{

n++;

q=q->next;

}

return(n);

}

void abort_ticket(elemtype x,char t[]) /*办理退票模块*/

{

ticket *s,*q;

q=back; /*q指向备份链表*/

s=(ticket *)malloc(sizeof(ticket)); /*需要办理退回的机票*/

s->seat=x;

strcpy(s->num,t);

while(strcmp(s->num,q->num)&&(s->seat!=q->seat)&&q) /*检查是否为有效票*/ q=q->next;

if(!q)

printf("对不起！你所退的不是本次飞机的车票！\n");

else /*为有效票办理退回业务*/

{

s->next=sale;

sale=s;

}

}

void sale_ticket() /*购票模块*/

{

ticket *t;

if(sale)

{

t=sale;

sale=sale->next; /*从销售链表中删除已售票所在的结点*/

printf("你购买飞机票的车次为：%s,座位号为:%d\n",t->num,t->seat); free(t);

}

else

printf("飞机票已售完！\n");

}

void display() /*输出模块*/

{

ticket *p;

p=sale;

if(p==null)

printf("飞机票已售完！");

else while(p!=null) /*输出所有剩余机票的机次，座位情况*/

{

printf("%3d,%5s",p->seat,p->num);

p=p->next;

if(p)

printf(",");

}

printf("\n");

}

void main()

{

ticket *q,*p;

char tl[4];

int d,i,n,select,flag=1;

sale=null; /*销售链表指针初始化*/

back=null; /*备份链表指针初始化*/

printf("请输入飞机座位数：");

scanf("%d",&n);

for(i=1;i<=n;i++) /*建立所有机票构成的销售链表和备份链表*/ {

q=(ticket *)malloc(sizeof(ticket));

p=(ticket *)malloc(sizeof(ticket));

printf("请输入机次：");

scanf("%s",q->num);

printf("请输入机票座位号：");

scanf("%d",&d);

q->seat=d;

q->next=sale;

sale=q;

p->seat=d;

p->next=back;

back=p;

printf("\n");

}

printf("飞机座位情况为：\n");

display();

printf("\n");

while(flag)

{

printf("1**********查询剩票数\n");

printf("2**********购票\n");

printf("3**********退票\n");

printf("4**********退出 \n");

printf("请选择您要执行的选项:");

scanf("%d",&select);

switch(select)

{

case 1:{d=count();

printf("\n剩余的机票数为：%d",d); printf("\n座位剩余情况为:");

display();

printf("\n");

}

break;

case 2:{ printf("\n购买机票:\n");

sale_ticket();

printf("\n");

display();

printf("\n");

}

break;

case 3:{ printf("\n退票:");

printf("请输入退票的机次:");

scanf("%s",tl);

printf("\n请输入退票的座位号:");

scanf("%d",&d);

abort_ticket(d,tl); display();

printf("\n");

}

break;

case 4:flag=0;

break;

}

}

}

测试实例

实验三栈和队列的基本操作（必做）

一、实验目的：

1.掌握栈与队列的数据类型描述及特点；

2.掌握栈和队列的存储；

3.掌握栈的顺序和链式存储存表示与入栈、出栈操作的程序实现；

4. 掌握队列的链式存储表示与入队、出队基本操作算法实现

二、实验内容

1.根据栈数据结构，分别建立一个顺序栈和链式栈并实现其上基本操作（出栈和入栈等）；

2.根据队列数据结构，分别建立链队列和循环队列，并完成其上的基本操作（出入队列等）。

三、实验步骤

1.定义一个顺序栈和链栈结构体（队列结构体）。

2.利用入栈功能保存数据。

3.利用出栈删除弹出栈内信息。

4.利用入队功能保存数据。

5.利用出队删除队列信息。

四、程序运行测试

1.入栈功能测试。

2.出栈功能测试。

3.入队功能测试。

4.出队功能测试。

五、实验报告要求

1.绘制程序实现的流程图。

2.详细给出程序运行测试结果（包括测试数据和测试结果）。

3.选试验步骤1、2中的任意一个，3、4中的任意一个给出程序的详细注释。

4.参考程序中某一部分功能的改进（选做）

5.实验心得与体会

6.附录，实验用源程序

六、参考源程序

顺序栈

#include

#define STACKSIZE 50

typedef char DateType;

typedef struct

{

DateType s[STACKSIZE];

int top;

}SeqStack;

int i;

DateType x;

void InitSt(SeqStack* st)

{

st->top=0;

cout<<"创建成功!";

}

void push(SeqStack *st,DateType x)

{

if(st->top==STACKSIZE)

{

cout<<"栈已满!";

}

else

{

st->s[st->top]=x;

st->top++;

cout<<"入栈成功!";

}

}

void pop(SeqStack *st)

{

i=st->top;

x=st->s[i-1];

if(st->top==0)

{

cout<<"栈为空!";

}

else

{

st->top--;

cout<<"出栈成功!";

cout<<"出栈元素为:"<

}

}

void readTop(SeqStack *st)

{

i=st->top;

if(st->top==0)

{

cout<<"栈为空!";

}

else

{

i--; cout<<"栈顶元素为:"<s[i];

}

}

void showSt(SeqStack *st)

{

if(st->top==0)

{

cout<<"栈为空!";

}

else

{

cout<<"栈中元素为:\n";

for(i=0;itop;i++)

{

cout<s[i];

}

}

}

void main()

int i,j;

DateType x;

SeqStack st;

while(j)

{

cout<<"\n\n\n\n";

cout<<"****************************************************************"<

cout<<"***①创建顺序栈②入栈③读栈顶元 ***"<

cout<<"***④出栈⑤显示链栈元素⑥退出 ***"<

cout<<"****************************************************************"<

cin>>i;

if(i==1)

{

InitSt(&st);

}

else if(i==2)

{

cout<<"请输入入栈元素:";

cin>>x;

push(&st,x);

}

else if(i==4)

{

pop(&st);

}

else if(i==3)

{

readTop(&st);

}

else if(i==5)

{

showSt(&st);

}

else if(i==6)

{

j=0;

cout<<"程序结束!\n";

}

}

链栈：

#include

#include

#include

typedef char DateType;

typedef struct node

{

DateType data;

struct node* next;

}LinkStack;

LinkStack *top;

void InitStack()

{

top=(LinkStack*)malloc(sizeof(LinkStack)); top->next=NULL;

top->data=0;

cout<<"初始化链栈成功!";

}

void push(DateType x)

{

LinkStack* s; s=(LinkStack*)malloc(sizeof(LinkStack));

s->data=x;

s->next=top;

top=s;

cout<<"入栈成功!";

}

void pop()

{

LinkStack* s;

s=top;

if(s==NULL)

{

cout<<"栈为空!";

}

else

{

top=s->next;

free(s);

cout<<"出栈成功";

}

void readTop()

{

if(top==NULL)

{

cout<<"栈为空!";

}

else

{

cout<<"栈顶元素为:"<data;

}

}

void showStack()

{

LinkStack* s;

s=top;

if(s==NULL)

{

cout<<"栈为空!";

}

else

{

cout<<"链栈元素为:\n";

cout<<"\t\t\t";

while(s!=NULL)

{

cout<<" "<data;

s=s->next;

}

}

}

void main()

{

int i,j;

DateType x;

while(j)

{

cout<<"\n\n\n\n";

cout<<"****************************************************************"<

cout<<"*** ①创建链栈②入栈③读栈顶元 ***"<

cout<<"*** ④出栈⑤显示链栈元素⑥退出***"<

cout<<"****************************************************************"<

cin>>i;

if(i==1)

{

InitStack();

}

else if(i==2)

{

if(top==NULL)

{

cout<<"请先初始化链表!";

}

else

{

cout<<"请输入要入栈的元素:";

cin>>x;

push(x);

}

}

else if(i==3)

{

pop();

}

else if(i==4)

{

readTop();

}

else if(i==5)

{

showStack();

}

else if(i==6)

{

j=0;

cout<<"程序结束\n";

}

}

}

链队列：

#include

#include

#define TRUE 1

#define FALSE 0

typedef int QElemType;

typedef struct LNode

{

QElemType data;

struct LNode *next;

}LNode , *LinkList;

typedef struct

{

LinkList front;

LinkList rear;

}LinkQueue;//链式队列

void InitQueue_L(LinkQueue &Q)//引用做参数，Q为结构体

{//初始化队列

Q.front=Q.rear=new LNode;

if(!Q.front) {cout<<"存储分配失败！"<next=NULL;

}

int IsEmpty(LinkQueue &Q)

{

if(Q.front==Q.rear)

{

return TRUE;

}

else

{

return FALSE;

}

}

//创建队列，数据元素由键盘输入

void CreateQueue_L(LinkQueue &Q)

{

QElemType temp;

LNode *p;

cout<<"输入要插入的队列值（输入-1结束）"<

cin>>temp;

while(temp != -1)

{

p=new LNode;

p->data=temp;

p->next=NULL;

Q.rear->next=p;

Q.rear=p;

cin>>temp;

}

cout<<"创建成功！"<

}

//入队操作

int EnterQueue(LinkQueue &Q,QElemType x)

{//将数据元素x插入到队列Q中

LNode *NewNode=new LNode;

if(!NewNode) {cout<<"存储分配失败！"<

{

NewNode->data=x;

NewNode->next=NULL;

Q.rear->next=NewNode;

Q.rear=NewNode;

cout<<"入队成功！"<

return(TRUE);

}

else return(FALSE); //溢出

}

//出队操作

int DeleteQueue(LinkQueue &Q,QElemType &x)

{//将队列Q的队头元素出队，并存放到x所指的存储空间中

LNode *p;

/*if(Q.front==Q.rear)

{

cout<<"该队列为空！"<

return(FALSE);

}*/

p=Q.front->next;

x=p->data;

Q.front->next=p->next; //队头元素p出队