《数据结构》(C语言版)实验

《数据结构》实验

信息工程学院

2015

预备实验C语言的函数数组指针结构体知识

一、实验目的

1、复习C语言中函数、数组、指针、结构体与共用体等的概念。

2、熟悉利用C语言进行程序设计的一般方法。

二、实验预习

说明以下C语言中的概念

1、函数：

2、数组：

3、指针：

4、结构体

5、共用体

三、实验内容和要求

1、(1)调试以下程序：输出100以内所有的素数（用函数实现）。

#include

int isprime(int n){ /*判断一个数是否为素数*/

int m;

for(m=2;m*m<=n;m++)

if(n%m==0) return 0;

return 1;

}

int main( ){ /*输出100以内所有素数*/

int i; printf("\n");

for(i=2;i<100;i++)

if(isprime(i)==1) printf("%4d",i);

return 0;

}

运行结果：

(2) 模仿（1），编写程序，求1！+2！+3！+……+n！（n=10）,要求阶乘用函数实现。

2、（1）调试程序：对一维数组中的元素进行逆序排列。

（2）修改所给的程序，设计三个函数：input(a)、output(a)、invert(a),分别实现一维数组的输入、输出和数据元素逆序排列运算，并在主函数中调用。

#include

#define N 10

int main(){

int a[N]={0,1,2,3,4,5,6,7,8,9},i,temp;

printf("\nthe original Array is:\n ");//输出原始数组元素0,1,2,3,4,5,6,7,8,9

for(i=0;i

printf("%4d",a[i]);

for(i=0;i

temp=a[i];

a[i]=a[N-i-1];

a[N-i-1]=temp;

}

printf("\nthe changed Array is:\n");//输出改变顺序后数组元素9,8,7,6,5,4,3,2,1,0

for(i=0;i

printf("%4d",a[i]);

return 0;

}

（1）运行结果：

（2）运行结果：

3、（选做）（1）调试程序：在二维数组中，若某一位置上的元素在该行中最大，而在该列中最小，则该元素即为该二维数组的一个鞍点。要求从键盘上输入一个二维数组，当鞍点存在时，把鞍点找出来。

（2）修改所给的程序，用函数实现：

编写输入函数：从键盘上输入一个二维数组。

编写查找鞍点函数：找到则返回鞍点值，没找到则返回“二维数组没有鞍点”。

编写输出函数：在屏幕上输出二维数组。

#include

#define M 3

#define N 4

int main(){

int a[M][N],i,j,k;

printf("\n请输入二维数组的数据：\n");

for(i=0;i

for(j=0;j

scanf("%d",&a[i][j]);

for(i=0;i

for(j=0;j

printf("%4d",a[i][j]);

printf("\n");

}

for(i=0;i

k=0;

for(j=1;j

if(a[i][j]>a[i][k])

k=j;

for(j=0;j

if(a[j][k]

break;

if(j==M) /*在第i行找到鞍点*/

printf("%d,%d,%d\n",a[i][k],i,k);

}

return 0;

}

运行结果：

4、（1）调试程序：利用指针输出二维数组的元素。

（2）修改程序：用三种方法输出二维数组中的元素（用函数实现）。

#include

int main(){

int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};

int *p;

for(p=a[0];p

if((p-a[0])%4==0) printf("\n");

printf("%4d",*p);

}

return 0;

}

运行结果：

5、（1）调试程序：设有一个教师与学生通用的表格，教师的数据有姓名、年龄、职业、教研室四项，学生有姓名、年龄、专业、班级四项，编程输入人员的数据，再以表格输出。

(2)修改所给程序，设计二个函数：input(s)、output(s)，用指针实现输入和输出人员的数据，并在主函数中调用。

#include

#define N 10

struct student{

char name[8]; /*姓名*/

int age; /*年龄*/

char job; /*职业或专业，用s或t表示学生或教师*/

union {

int class; /*班级*/

char office[10]; /*教研室*/

}depa;

}stu[N];

int main(){

int i,n;

printf(“\n请输入人员数(<10):\n”);

scanf(“%d”,&n);

for(i=0;i

printf("\n请输入第%d人员的信息：(name age job class/office)\n",i+1);

scanf("%s,%d,%c",stu[i].name, &stu[i].age, &stu[i].job);

if(stu[i].job==’s’)

scanf("%d",&stu[i].depa.class);

else

scanf("%s",stu[i].depa.office);

}

printf(“name age job class/office”);

for(i=0;i

if(stu[i].job==’s’)

printf("%s %3d %3c %d\n",stu[i].name, stu[i].age, stu[i].job, stu[i].depa.class);

else

printf("%s %3d %3c %s\n",stu[i].name, stu[i].age, stu[i].job, stu[i].depa.office);

}

}

输入的数据：2

Wang 19 s 99061

Li 36 t computer

运行结果：

四、实验小结

五、教师评语

实验一顺序表与链表

一、实验目的

1、掌握线性表中元素的前驱、后续的概念。

2、掌握顺序表与链表的建立、插入元素、删除表中某元素的算法。

3、对线性表相应算法的时间复杂度进行分析。

4、理解顺序表、链表数据结构的特点（优缺点）。

二、实验预习

说明以下概念

1、线性表：

2、顺序表：

3、链表：

三、实验内容和要求

1、阅读下面程序，在横线处填写函数的基本功能。并运行程序，写出结果。#include

#include

#define ERROR 0

#define OK 1

#define INIT_SIZE 5 /*初始分配的顺序表长度*/

#define INCREM 5 /*溢出时，顺序表长度的增量*/

typedef int ElemType; /*定义表元素的类型*/

typedef struct Sqlist{

ElemType *slist; /*存储空间的基地址*/

int length; /*顺序表的当前长度*/

int listsize; /*当前分配的存储空间*/

}Sqlist;

int InitList_sq(Sqlist *L); /* */

int CreateList_sq(Sqlist *L,int n); /* */

int ListInsert_sq(Sqlist *L,int i,ElemType e);/* */ int PrintList_sq(Sqlist *L); /*输出顺序表的元素*/

int ListDelete_sq(Sqlist *L,int i); /*删除第i个元素*/

int ListLocate(Sqlist *L,ElemType e); /*查找值为e的元素*/

int InitList_sq(Sqlist *L){

L->slist=(ElemType*)malloc(INIT_SIZE*sizeof(ElemType));

if(!L->slist) return ERROR;

L->length=0;

L->listsize=INIT_SIZE;

return OK;

}/*InitList*/

int CreateList_sq(Sqlist *L,int n){

ElemType e;

int i;

for(i=0;i

printf("input data %d",i+1);

scanf("%d",&e);

if(!ListInsert_sq(L,i+1,e))

return ERROR;

}

return OK;

}/*CreateList*/

/*输出顺序表中的元素*/

int PrintList_sq(Sqlist *L){

int i;

for(i=1;i<=L->length;i++)

printf("%5d",L->slist[i-1]);

return OK;

}/*PrintList*/

int ListInsert_sq(Sqlist *L,int i,ElemType e){

int k;

if(i<1||i>L->length+1)

return ERROR;

if(L->length>=L->listsize){

L->slist=(ElemType*)realloc(L->slist,(INIT_SIZE+INCREM)*sizeof(ElemType ));

if(!L->slist)

return ERROR;

L->listsize+=INCREM;

}

for(k=L->length-1;k>=i-1;k--){

L->slist[k+1]= L->slist[k];

}

L->slist[i-1]=e;

L->length++;

return OK;

}/*ListInsert*/

/*在顺序表中删除第i个元素*/

int ListDelete_sq(Sqlist *L,int i){

}

/*在顺序表中查找指定值元素，返回其序号*/

int ListLocate(Sqlist *L,ElemType e){

}

int main(){

Sqlist sl;

int n,m,k;

printf("please input n:"); /*输入顺序表的元素个数*/

scanf("%d",&n);

if(n>0){

printf("\n1-Create Sqlist:\n");

InitList_sq(&sl);

CreateList_sq(&sl,n);

printf("\n2-Print Sqlist:\n");

PrintList_sq(&sl);

printf("\nplease input insert location and data:(location,data)\n");

scanf("%d,%d",&m,&k);

ListInsert_sq(&sl,m,k);

printf("\n3-Print Sqlist:\n");

PrintList_sq(&sl);

printf("\n");

}

else

printf("ERROR");

return 0;

}

●运行结果

●算法分析

2、为第1题补充删除和查找功能函数，并在主函数中补充代码验证算法的正确性。删除算法代码：

●运行结果

●算法分析

查找算法代码：

●运行结果

●算法分析

3、阅读下面程序，在横线处填写函数的基本功能。并运行程序，写出结果。

#include

#include

#define ERROR 0

#define OK 1

typedef int ElemType; /*定义表元素的类型*/

typedef struct LNode{ /*线性表的单链表存储*/

ElemType data;

struct LNode *next;

}LNode,*LinkList;

LinkList CreateList(int n); /* */ void PrintList(LinkList L); /*输出带头结点单链表的所有元素*/

int GetElem(LinkList L,int i,ElemType *e); /* */

LinkList CreateList(int n){

LNode *p,*q,*head;

int i;

head=(LinkList)malloc(sizeof(LNode)); head->next=NULL; p=head;

for(i=0;i

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

printf("input data %i:",i+1);

scanf("%d",&q->data); /*输入元素值*/

q->next=NULL; /*结点指针域置空*/

p->next=q; /*新结点连在表末尾*/

p=q;

}

return head;

}/*CreateList*/

void PrintList(LinkList L){

LNode *p;

p=L->next; /*p指向单链表的第1个元素*/

while(p!=NULL){

printf("%5d",p->data);

p=p->next;

}

}/*PrintList*/

int GetElem(LinkList L,int i,ElemType *e){

LNode *p;int j=1;

p=L->next;

while(p&&j

p=p->next;j++;

}

if(!p||j>i)

return ERROR;

*e=p->data;

return OK;

}/*GetElem*/

int main(){

int n,i;ElemType e;

LinkList L=NULL; /*定义指向单链表的指针*/

printf("please input n:"); /*输入单链表的元素个数*/

scanf("%d",&n);

if(n>0){

printf("\n1-Create LinkList:\n");

L=CreateList(n);

printf("\n2-Print LinkList:\n");

PrintList(L);

printf("\n3-GetElem from LinkList:\n");

printf("input i=");

scanf("%d",&i);

if(GetElem(L,i,&e))

printf("No%i is %d",i,e);

else

printf("not exists");

}else

printf("ERROR");

return 0;

}

●运行结果

●算法分析

4、为第3题补充插入功能函数和删除功能函数。并在主函数中补充代码验证算法的正确性。插入算法代码：

●运行结果●算法分析删除算法代码：

●运行结果●算法分析

以下为选做实验：

5、循环链表的应用（约瑟夫回环问题）

n个数据元素构成一个环，从环中任意位置开始计数，计到m将该元素从表中取出，重复上述过程，直至表中只剩下一个元素。

提示：用一个无头结点的循环单链表来实现n个元素的存储。

●算法代码

6、设一带头结点的单链表，设计算法将表中值相同的元素仅保留一个结点。

提示：指针p从链表的第一个元素开始，利用指针q从指针p位置开始向后搜索整个链表，删除与之值相同的元素；指针p继续指向下一个元素，开始下一轮的删除，直至p＝＝null 为至，既完成了对整个链表元素的删除相同值。

●算法代码

四、实验小结

五、教师评语

实验二栈和队列

一、实验目的

1、掌握栈的结构特性及其入栈，出栈操作；

2、掌握队列的结构特性及其入队、出队的操作，掌握循环队列的特点及其操作。

二、实验预习

说明以下概念

1、顺序栈：

2、链栈：

3、循环队列：

4、链队

三、实验内容和要求

1、阅读下面程序，将函数Push和函数Pop补充完整。要求输入元素序列1 2 3 4 5 e，运行结果如下所示。

#include

#include

#define ERROR 0

#define OK 1

#define STACK_INT_SIZE 10 /*存储空间初始分配量*/

#define STACKINCREMENT 5 /*存储空间分配增量*/

typedef int ElemType; /*定义元素的类型*/

typedef struct{

ElemType *base;

ElemType *top;

int stacksize; /*当前已分配的存储空间*/

}SqStack;

int InitStack(SqStack *S); /*构造空栈*/

int push(SqStack *S,ElemType e); /*入栈*/

int Pop(SqStack *S,ElemType *e); /*出栈*/

int CreateStack(SqStack *S); /*创建栈*/

void PrintStack(SqStack *S); /*出栈并输出栈中元素*/

int InitStack(SqStack *S){

S->base=(ElemType *)malloc(STACK_INT_SIZE *sizeof(ElemType)); if(!S->base) return ERROR;

S->top=S->base;

S->stacksize=STACK_INT_SIZE;

return OK;

}/*InitStack*/

int Push(SqStack *S,ElemType e){

}/*Push*/

int Pop(SqStack *S,ElemType *e){

}/*Pop*/

int CreateStack(SqStack *S){

int e;

if(InitStack(S))

printf("Init Success!\n");

else{

printf("Init Fail!\n");

return ERROR;

}

printf("input data:(Terminated by inputing a character)\n"); while(scanf("%d",&e))

Push(S,e);

return OK;

}/*CreateStack*/

void PrintStack(SqStack *S){

ElemType e;

while(Pop(S,&e))

printf("%3d",e);

}/*Pop_and_Print*/

int main(){

SqStack ss;

printf("\n1-createStack\n");

CreateStack(&ss);

printf("\n2-Pop&Print\n");

PrintStack(&ss);

return 0;

}

●算法分析：输入元素序列1 2 3 4 5，为什么输出序列为5 4 3 2 1？体现了栈的什么

特性？

2、在第1题的程序中，编写一个十进制转换为二进制的数制转换算法函数（要求利用栈来实现），并验证其正确性。

●实现代码

●验证

3、阅读并运行程序，并分析程序功能。

#include

#include

#include

#define M 20

#define elemtype char

typedef struct

elemtype stack[M];

int top;

}

stacknode;

void init(stacknode *st);

void push(stacknode *st,elemtype x);

void pop(stacknode *st);

void init(stacknode *st)

{

st->top=0;

}

void push(stacknode *st,elemtype x)

{

if(st->top==M)

printf("the stack is overflow!\n"); else

{

st->top=st->top+1;

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

}

}

void pop(stacknode *st)

{

if(st->top>0) st->top--;

else printf(“Stack is Empty!\n”);

}

int main()

{

char s[M];

int i;

stacknode *sp;

printf("create a empty stack!\n");

sp=malloc(sizeof(stacknode));

init(sp);

printf("input a expression:\n");

gets(s);

for(i=0;i

{

if(s[i]=='(')

push(sp,s[i]);

if(s[i]==')')

pop(sp);

}

if(sp->top==0)

printf("'('match')'!\n");

else

printf("'('not match')'!\n");

return 0;

}

●输入：2+((c-d)*6-(f-7)*a)/6

●运行结果：

●输入：a-((c-d)*6-(s/3-x)/2

●运行结果：

●程序的基本功能：

以下为选做实验：

4、设计算法，将一个表达式转换为后缀表达式，并按照后缀表达式进行计算，得出表达式得结果。

●实现代码

5、假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾结点（不设队头指针），试编写相应的置空队列、入队列、出队列的算法。

实现代码：

四、实验小结

五、教师评语

实验三串的模式匹配（选做）

一、实验目的

1、了解串的基本概念

2、掌握串的模式匹配算法的实现

二、实验预习

说明以下概念

1、模式匹配：

2、BF算法：

3、KMP算法：

三、实验内容和要求

1、阅读并运行下面程序，根据输入写出运行结果。

#include

#include

#define MAXSIZE 100

typedef struct{

char data[MAXSIZE];

int length;

}SqString;

int strCompare(SqString *s1,SqString *s2); /*串的比较*/

void show_strCompare();

void strSub(SqString *s,int start,int sublen,SqString *sub); /*求子串*/

void show_subString();

int strCompare(SqString *s1,SqString *s2){

int i;

for(i=0;ilength&&ilength;i++)

if(s1->data[i]!=s2->data[i])

return s1->data[i]-s2->data[i];

return s1->length-s2->length;

}

void show_strCompare(){

SqString s1,s2;

int k;

printf("\n***show Compare***\n");