数据结构实验指导书new(完整版)

数据结构实验指导书

实验一线性表的创建与应用

一、实验目的

1、掌握线性表的定义

2、掌握线性表的基本操作：插入、删除、查找以及线性表合并等运算在链接存储结构上的运算。

二、实验内容

1、阅读并运行本实验程序（有序顺序表实现）

2、用单链表方式实现本程序相应功能（有序单链表）

3、利用有序单链表实现一元多项式的加法的功能。

三、实验要求

1、认真阅读和掌握本实验的参考程序（有序顺序表）。

2、上机运行该程序。

3、保存和打印出程序的运行结果，并结合程序进行分析。

4、按照有序顺序表功能，重新改写程序并运行，打印出文件清单和运行结果

5、创建有序单链表时，要用头插法和尾插法同时实现。

6、实现一元多项式的加法的功能，并输出结果。

7、最好能将结果写入到文本文件中。

四、注意事项：

1、实验学时：4学时

2、实验完成一周内提交实验报告（实验报告本）

3、实验结果要求抓图打印

4、严禁抄袭

五、实验附件程序（有序顺序表）

Odsqlist.h文件：

#define LIST_INIT_SIZE 8 //线性表存储空间的初始分配量

#define LISTINCREMENT 10 //线性表存储空间的分配增量

#define OVERFLOW -2

#define ERROR 0

#define OK 1

#define TRUE 1

#define FALSE 0

typedef int Status;

typedef int ElemType;

typedef struct {

ElemType *elem; // 存储空间基址

int length; // 当前长度

int listsize; // 当前分配的存储容量(以sizeof(ElemType)为单位)

}SqList; // 俗称顺序表

typedef SqList OdSqList; //有序顺序表

Status InitList(OdSqList&); // 结构初始化

void Destroy(OdSqList&); //销毁有序顺序表

void ClearList(OdSqList&);//清空有序表

Status ListEmpty(OdSqList);//判有序表为空

int ListLength(OdSqList);//求表长

int LocateElem(OdSqList,ElemType); // 查找

void ListInsert(OdSqList&,ElemType); // 插入元素

Status ListDelete(OdSqList&, int,ElemType& ); // 删除元素

int ListDeletem(OdSqList&L, ElemType e); // 删除所有值为e的元素,返回删除的元素个数

int ListDeletemn(OdSqList&, ElemType, ElemType ); // 删除所有值界于mink~maxk的元素，并返回删除的元素个数

void ListTraverse(OdSqList);//遍历非递减有序线性表

odsqlist.cpp文件：

#include

#include

#include "odsqlist.h"

Status InitList( OdSqList& L ){

// 构造一个空的线性表

L.elem = (ElemType*) malloc (LIST_INIT_SIZE*sizeof(ElemType));

if (!L.elem)

exit(OVERFLOW);

L.length = 0;

L.listsize = LIST_INIT_SIZE;

return OK;

} // InitList

void ListTraverse(OdSqList L){

//遍历线性表

int i;

printf("listsize is %d.\n",L.listsize);

printf("listlength is %d.\n",L.length);

printf("the list is:(");

for(i=1;i<=L.length;i++)

printf("%d ",L.elem[i-1]);

printf(")\n");

}

int LocateElem(OdSqList L, ElemType e){

// 在顺序表中查询第一个满足判定条件的数据元素，若存在，则返回它的位序，否则返回 0

int i;

i = 1; // i 的初值为第 1 元素的位序

ElemType *p;

p = L.elem; // p 的初值为第 1 元素的存储位置

while (i <= L.length && *p++!=e) ++i;

if (i <= L.length) return i;

else return 0;

}

void ListInsert(OdSqList &L, ElemType e) {

// 在顺序表L中保序插入新的元素e

ElemType *newbase,*p,*q;

if (L.length >= L.listsize) { // 当前存储空间已满，增加分配

newbase = (ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof (ElemType));

if (!newbase) exit(OVERFLOW);// 存储分配失败

L.elem = newbase; // 新基址

L.listsize += LISTINCREMENT; // 增加存储容量

}

q = &(L.elem[0]); // q 指示第1个元素位置

for (p = &(L.elem[L.length-1]);p>=q&&*p>e; --p)

*(p+1) = *p; // 插入位置及之后的元素右移

*(p+1) = e; // 插入e

++L.length; // 表长增1

}

Status ListDelete(OdSqList &L, int i, ElemType &e) {

ElemType *p,*q;

if ((i < 1) || (i > L.length)) return ERROR;// 删除位置不合法

p = &(L.elem[i-1]); // p 为被删除元素的位置

e = *p; // 被删除元素的值赋给 e

q = L.elem+L.length-1; // 表尾元素的位置

for (++p; p <= q; ++p) *(p-1) = *p;

// 被删除元素之后的元素左移

--L.length; // 表长减1

return OK;

}

void Destroy(OdSqList& L){

//销毁有序顺序表

free(L.elem);

}

void ClearList(OdSqList& L){

//清空有序表

L.length=0;

}

Status ListEmpty(OdSqList L){

//判有序表为空

if(L.length==0)

return TRUE;

else return FALSE;

}

int ListLength(OdSqList L){

//求表长

return L.length;

}

int ListDeletem(OdSqList& L, ElemType e){

// 删除所有值为e的元素,返回删除的元素个数

ElemType *p,*q,*r;

int i=0;//删除的元素个数

p=&L.elem[0];//扫描指针

for(q=&L.elem[L.length-1];*p

if(p<=q&&*p==e){

i++;

for(r=p+1;*r==e&&r<=q;r++,i++);

if(r<=q)

for(;r<=q;r++,p++)

*p=*r;

}

L.length-=i;

return i;

}

int ListDeletemn(OdSqList& L, ElemType mink, ElemType maxk){

// 删除所有值界于mink~maxk的元素，并返回删除的元素个数

ElemType *p,*q,*r,temp;

int i=0;

if(maxk

temp=maxk;

maxk=mink;

mink=temp;

}

p=&L.elem[0];

for(q=&L.elem[L.length-1];*p

i++;

for(r=p+1;*r<=maxk&&r<=q;r++,i++);//r指针指向第1个大于maxk的元素

if(r<=q)

for(;r<=q;r++,p++)

*p=*r;

}

L.length-=i;

return i;

}

app.cpp文件:

#include

#include

#include "odsqlist.h"

void main(){

OdSqList L;

int k;

char i;

ElemType e,mink,maxk;

printf("OdSqList is init……\n");

i=InitList(L);

ListTraverse(L);

while(1){

printf("\n\nplease select:\n");

printf("1------insert\n");

printf("2------traverse\n");

printf("3------deletei\n");

printf("4------deletek\n");

printf("5------deletemink-maxk\n");

printf("6------locate\n");

printf("7------isempty\n");

printf("8------length\n");

printf("9------clearlist\n");

printf("0------quit\n");

scanf("%d",&k);

switch(k){

case 1:

printf("please input e:");

scanf("%d",&e);

ListInsert(L,e);

ListTraverse(L);

scanf("%c",&i);

printf("please press any key to continue……");

scanf("%c",&i);

break;

case 2:

ListTraverse(L);

scanf("%c",&i);

printf("please press any key to continue……");

scanf("%c",&i);

break;

case 3:

while(1){

printf("please input delete i:");

scanf("%d",&i);

if(ListDelete(L,i,e)==ERROR)

printf("delete positon is error!\n");

else {

printf("Deleted elem is %d\n",e);

break;

}

}

ListTraverse(L);

scanf("%c",&i);

printf("please press any key to continue……");

scanf("%c",&i);

break;

case 4:

printf("please input delete e:");

scanf("%d",&e);

ListTraverse(L);

printf("%d elem is deleted.\n",ListDeletem(L,e));

ListTraverse(L);

scanf("%c",&i);

printf("please press any key to continue……");

scanf("%c",&i);

break;

case 5:

printf("please input delete mink and maxk:");

scanf("%d%d",&mink,&maxk);

ListTraverse(L);

printf("%d elem is deleted.\n",ListDeletemn(L,mink,maxk));

ListTraverse(L);

scanf("%c",&i);

printf("please press any key to continue……");

scanf("%c",&i);

break;

case 6:

printf("please input locate e:");

scanf("%d",&e);

i=LocateElem(L,e);

if(i==0)

printf("locate Defaulted!\n");

else

printf("located no. is %d\n",i);

ListTraverse(L);

scanf("%c",&i);

printf("please press any key to continue……");

scanf("%c",&i);

break;

case 7:

if(ListEmpty(L))

printf("the orderlist is empty!\n");

else

printf("the orderlist is not empty!\n");

scanf("%c",&i);

printf("please press any key to continue……");

scanf("%c",&i);

break;

case 8:

printf("length is %d.\n",ListLength(L));

scanf("%c",&i);

printf("please press any key to continue……");

scanf("%c",&i);

break;

case 9:

ClearList(L);

printf("the orderlist is empty!\n");

scanf("%c",&i);

print f("please press any key to continue……");

scanf("%c",&i);

break;

case 0:

Destroy(L);

exit(1);

break;

}

}

}

实验二栈（队列）的创建与应用

一、实验目的

1.掌握栈（队列）的基本操作：初始化栈（队列）、判栈（队列）为空、出栈（队列）、入栈（队列）等

运算。

2.掌握栈（队列）的应用方法，应用特点。

二、实验要求

1．认真阅读和掌握本实验提供的参考算法程序。

2．上机实现实验内容算法。

3．保存和打印出程序的运行结果，并结合程序进行分析。

三、实验内容

1.表达式求值：已提供的表达式求值程序结构不好，请改进，要求用多文件方式实现，并将中序表达式变

为后序表达式的结果写入文件。

2.迷宫问题：已提供的迷宫问题算法程序有栈和队列实现两种方式，请你分别改进，要求用多文件方式实现，并将最终的路径写入文件。

（以上提供的源码已随课件发给大家了）

四、实验学时

实验学时：2学时

实验三树的创建与应用

一、实验目的

1．掌握二叉树的二叉链表的定义方法。

2．掌握基于二叉链表的二叉树的创建和遍历。

3．掌握用线索二叉树的创建和遍历。

二、实验要求

1．认真阅读和掌握本实验提供的参考算法程序。

2．上机实现实验内容算法。

3．保存和打印出程序的运行结果，并结合程序进行时空复杂度分析。

三、实验学时

四、实验学时

实验学时：4学时

四、实验步骤及内容

1.创建二叉树和实现二叉树的三种遍历。

a.创建二叉树：根据提示输入字符型数据创建二叉树，输入值为所有字符型数据。

b.并能实现二叉树的先序、中序、后序的递归遍历：输出的结果为遍历后的每个结点的值的顺序。

2.在步骤1的基础上分别按照先序、中序、后序添加线索，再实现基于线索二叉树的遍历。

实验四图的存储与遍历

一．实验目的

1．掌握图的基本存储方法。

2．掌握有关图的操作算法并用高级语言编程实现；

3．熟练掌握图的两种搜索路径的遍历方法。

二．实验要求

1．认真阅读和掌握本实验的算法。

2．上机将本算法实现。

3．保存和打印出程序的运行结果，并结合程序进行分析。

4．按照你对图的操作需要，重新改写主程序并运行，打印出文件清单和运行结果

三、实验学时

实验学时：4学时

四．实验内容

以邻接矩阵和邻接表的方式存储连通图。然后分别用深度优先算法遍历邻接矩阵方式存储的图和邻接表方式存储的图。

算法如下：

深度优先遍历的递归算法

（1）深度优先遍历算法

int visited[MaxVertexNum]； //访问标志向量是全局量

void DFSTraverse(ALGraph *G)

{ //深度优先遍历以邻接表表示的图G，而以邻接矩阵表示G时，算法完全与此相同

int i；

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

visited[i]=FALSE； //标志向量初始化

for(i=0;in；i++)

if(!visited[i]) //vi未访问过

DFS(G，i)； //以vi为源点开始DFS搜索

}//DFSTraverse

（2）邻接表表示的深度优先搜索算法

void DFS(ALGraph *G，int i){

//以vi为出发点对邻接表表示的图G进行深度优先搜索

EdgeNode *p；

printf("visit vertex：％c"，G->adjlist[i].vertex)；//访问顶点vi

visited[i]=TRUE； //标记vi已访问

p=G->adjlist[i].firstedge； //取vi边表的头指针while(p){//依次搜索vi的邻接点vj，这里j=p->adjvex if (!visited[p->adjvex])//若vi尚未被访问

DFS(G，p->adjvex);//则以Vj为出发点向纵深搜索

p=p->next； //找vi的下一邻接点

}

}//DFS

#define MaxVertexNum 5

#define m 5

#define NULL 0

typedef struct node

{i n t a d j v e x;

struct node *next;

}JD;

typedef struct tnode

{ int vexdata;

JD *firstarc;

}TD;

typedef struct

{

TD ag[m];

int n;

}ALGRAPH;

void DFS(ALGRAPH *G,int i);

void creat(ALGRAPH *G)

{int i,m1,j;

JD *p,*p1;

printf("please input the number of graph\n"); scanf("%d",&G->n);

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

{printf("please input the info of node %d",i);

scanf("%d",&G->ag[i].vexdata);

printf("please input the number of arcs which adj to %d",i); scanf("%d",&m1);

printf("please input the adjvex position of the first arc\n"); p=(JD *)malloc(sizeof(JD));

scanf("%d",&p->adjvex);

p->next=NULL;

G->ag[i].firstarc=p;

p1=p;

for(j=2 ;j<=m1;j++)

{printf("please input the position of the next arc vexdata\n"); p=(JD *)malloc(sizeof(JD));

scanf("%d",&p->adjvex);

p->next=NULL;

p1->next=p;

p1=p;}

}

}

int visited[MaxVertexNum];

void DFSTraverse(ALGRAPH *G)

{

int i;

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

visited[i]=0;

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

if(!visited[i])

DFS(G,i);

}/*DFSTraverse */

void DFS(ALGRAPH *G,int i){

JD *p;

printf("visit vertex:%d->",G->ag[i].vexdata);

visited[i]=1; /*标记vi已访问 */

p=G->ag[i].firstarc; /*取vi边表的头指针*/

while(p){/*依次搜索vi的邻接点vj，这里j=p->adjvex*/

if (!visited[p->adjvex])/*若vi尚未被访问 */

DFS(G,p->adjvex);/*则以Vj为出发点向纵深搜索 */

p=p->next;

}

}/*DFS */

main()

{ ALGRAPH *G;

printf("下面以临接表存储一个图；\n"); creat(G);

printf("下面以深度优先遍历该图 \n"); DFSTraverse(G);

getch();

}

实验五排序

一、实验目的

1．掌握简单插入排序、冒泡排序、快速排序、堆排序以及归并排序的算法并加以应用。

2．对各种查找、排序技术的时间、空间复杂性有进一步认识。

二、实验要求

1．认真阅读和掌握和本实验相关的教材内容。

2．编写完整程序完成下面的实验内容并上机运行。

3．整理并上交实验报告。

三、实验学时

实验学时：2学时

四、实验内容

编写程序实现下述五种算法，并用以下无序序列加以验证：

49，38，65，97，76，13，27，49

1．简单插入排序

2．冒泡排序

3．快速排序

4．归并排序

5．堆排序

四、思考与提高

1．设有1000个无序的元素，希望用最快的速度挑出其中前10个最大的元素，采用哪一种排序方法最好？为什么？

2．如何构造一种排序方法，使五个整数至多用七次比较就可以完成排序任务？