数据结构-实验报告2栈和队列-王浩文

数据结构实验报告

一、抄写自己所选择的题目。

1、称正读和反读都相同的字符序列为“回文”，例如，abcddcba、qwerewq是回文，ashgash不是回文。试写一个算法，判断读入的一个以“@”为结束符的字符序列是否为回文。

2、假设以数组se[m]存放循环队列的元素，同时设变量rear和front分别作为队首、队尾指针，且队首指针指向队首节点前一个位置，写出这样设计的循环队列的入队、出队的算法。

二、写出算法设计思路。

1.先分配一个含80个字符的数组用来存放输入的字符序列，再构造一个结构体，以堆栈

的方式将字符序列入栈，然后出栈并与相应的顺序数组挨个进行比较，直到出现不相等的情况，就输出“不是回文”，否则在结束比较后输出“是回文”。

2.先分配一个数组用来存放输入的char。然后按照用户的长度要求将字符串存入顺序列表

中，再输出到屏幕。

三、编写代码，调试运行，实现题目要求（提示：考虑到插入和删除的位置是否超出范

围等可能出现的异常问题）

1./* 称正读和反读都相同的字符序列为"回文"，例如，abcddcba、qwerewq是回文，

ashgash不是回文。试写一个算法，判断读入的一个以"@"为结束符的字符序列

是否为回文。*/

typedef char SElemType;

#include"c-head.h"

#include"hong.h"

#include"shunxz.c"

#define CHECK 0

/* 宏定义，方便调试 */

main()

{

SqStack s;

char ch[80],*p,e; /*char 他们*/

int t,i,k=1;

if(InitStack(&s)) /* 初始化栈成功 */

{

printf("请输入以“@”结尾的字符序列: ");

gets(ch);

p=ch;

}

while(*p)

if(*p!=64)

Push(&s,*p++);

else

{

t=StackLength(s);

printf("您一共输入了%d个字符。\n\n\n",t);

p++;

}

printf("正在比较中：\n");

printf("正读反读\n");

for(i=0;i

{

Pop(&s,&e);

printf(" %c -><- %c\n",ch[i],e);

if(ch[i]!=e){printf("您输入的字符序列“不是”回文。\n");

if(CHECK)printf("no."); k=0;break;}

}

if(k)

printf("您输入的字符序列“是”回文。\n");

if(CHECK){if(k)printf("yes.");}

getch();

}

/* c-head.h (程序名) */

#include

#include

#include /* malloc()等 */

#include /* INT_MAX等 */

#include /* EOF(=^Z或F6),NULL */

#include /* atoi() */

#include /* eof() */

#include /* floor(),ceil(),abs() */

#include /* exit() */

#include

/* 函数结果状态代码 */

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行 */ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */

/* hong.h 栈的顺序存储表示 */

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

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

typedef struct SqStack

{

SElemType *base; /* 在栈构造之前和销毁之后，base的值为NULL */

SElemType *top; /* 栈顶指针 */

int stacksize; /* 当前已分配的存储空间，以元素为单位 */

}SqStack; /* 顺序栈 */

/* shunxz.c 顺序栈（存储结构由hong.h定义）的基本操作 */

Status InitStack(SqStack *S)

{ /* 构造一个空栈S */

(*S).base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));

if(!(*S).base)

exit(OVERFLOW); /* 存储分配失败 */

(*S).top=(*S).base;

(*S).stacksize=STACK_INIT_SIZE;

return OK;

}

int StackLength(SqStack S)

{ /* 返回S的元素个数，即栈的长度 */

return S.top-S.base;

}

Status Push(SqStack *S,SElemType e)

{ /* 插入元素e为新的栈顶元素 */

if((*S).top-(*S).base>=(*S).stacksize) /* 栈满，追加存储空间 */

{

(*S).base=(SElemType

*)realloc((*S).base,((*S).stacksize+STACKINCREMENT)*sizeof(SElemType));

if(!(*S).base)

exit(OVERFLOW); /* 存储分配失败 */

(*S).top=(*S).base+(*S).stacksize;

(*S).stacksize+=STACKINCREMENT;

}

*((*S).top)++=e;

return OK;

}

Status Pop(SqStack *S,SElemType *e)

{ /* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */ if((*S).top==(*S).base)

return ERROR;

*e=*--(*S).top;

return OK;

}

2./* 假设以数组se[m]存放循环队列的元素，同时设变量rear和front分别作为队首、队尾指针，且队首指针指向队首节点前一个位置，写出这样设计的循环队列的入队、出队的算法。*/

typedef char QElemType;

#include "c-head.h"

#include "xhdl.h"

#include "xhdl.c"

#define TEST 0

main()

{

SqQueue q;

int m,se[80],i,*p,t;

char e;

if(InitQueue(&q)) /* 初始化队列成功 */

{

printf("Please input the length of the SqQueue: ");

scanf("%d",&m);

if(TEST) printf("\n***************\ntest:m=%d\n**********\n",m);

}

printf("Please input your char:");

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

scanf("%c",&se[i]);

p=se;

printf("Your char is: ");

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

printf("%c",p[i]);

while(*p) /*入队*/

{

EnQueue(&q,*p++);

if(TEST)printf("\n***************\ntest:%c\n**********\n",*p); }

t=QueueLength(q);

printf("\nThere are %d chars in the SqQueue:",t-1);

while(t) /*出队*/

{

DeQueue(&q,&e);t--;printf("%c",e);

}

getch();

}

/* "xunhdl.h"文件——循环队列 */

#define MAXQSIZE 100

/*最大队列长度 */

typedef struct SqQueue

{

QElemType *base; /*初始化的动态分配空间 */

int front; /*头指针*/

int rear; /*尾指针*/

}SqQueue; /*定义循环队列*/

/* "xhdl.c"——循环队列基本操作 */

Status InitQueue(SqQueue *Q)

{ /* 构造一个空队列Q */

(*Q).base=(QElemType *)malloc(MAXQSIZE *sizeof(QElemType));

if(!(*Q).base)

exit(OVERFLOW); /*储存分配失败 */

(*Q).front=(*Q).rear=0;

return OK;

}

int QueueLength(SqQueue Q)

{ /*返回Q的元素个数，即队列的长度 */

return(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;

}

Status EnQueue(SqQueue *Q,QElemType e)

{ /*插入e为Q的新的队尾元素*/

if(((*Q).rear+1)%MAXQSIZE==(*Q).front)return ERROR;/*队列满*/

(*Q).base[(*Q).rear]=e;

(*Q).rear=((*Q).rear+1)%MAXQSIZE;

return OK;

}

Status DeQueue(SqQueue *Q,QElemType *e)

{ /*若队列不空，则删除Q的队头元素，用e返回其值，并返回OK;否则返回ERROR*/ if((*Q).front==(*Q).rear) return ERROR;

*e=(*Q).base[(*Q).front];

(*Q).front=((*Q).front+1)%MAXQSIZE;

return OK;

}

运行结果：

四、写出算法设计、编程和调试运行的体会。

1.这是一个思路很简单的算法，但是由于C语言结构体中运用链表的相关知识比较薄弱,因而我花费了相当多的时间来建立和正确使用结构体与指针。

于此同时，在“.c”文件调用多次失败的过程中我发现一个问题就是：被调用文件的文件名不能太长，否则“Win-tc”将不能正常打开它。

至于调试过程应该说比较简单，没有什需要提的。

2.算法思路很简单，按照用户要求读入字符串，然后存入顺序列表，接着输出即可。但是在调试过程中出现了不少问题。

首先是“gets”函数无法正常运行，但是如果单把它拿出来放在一个main函数中就可以正常运作。然后，我不得不用scanf代替gets进行编程。结果scanf的读入也存在问题就是它不会把数据存在数组的第一个位置。这使我很困惑。

其次是课本中给的源代码要加指针符号才能用。比如“Q.base”要修改成“(*Q).base”。