《软件技术基础》实验指导 实验二

栈和队列

实验二 栈和队列

一、实验目的

1. 熟悉栈和队列的顺序和链式存储结构

2. 掌握栈和队列的基本运算

3. 能够利用栈和队列的基本运算完成栈和队列应用的运算

二、实验内容

1. 设单链表中存放有n个字符，试编写算法，判断该字符串是否有中心对称的关系，例如xyzzyx是中心对称的字符串。
   提示：将单链表中的一半字符先依次进栈，然后依次出栈与单链表中的另一半字符进行比较。

2. 假设以数组sequ[m]存放循环队列的元素，同时设变量rear和quelen 分别指示循环队列中队尾元素的位置和内含元素的个数。编写实现该循环队列的入队和出队操作的算法。
   提示：队空的条件：q->quelen==0；队满的条件：sq->quelen==m。

Tips

1. 使用栈的先进后出的特性进行比较，前一半push，后一把pop，加上判断是否相等就好。

2. 循环顺序队列的出入操作，提供的结构中有队尾指针，队长。可以通过这两个变量得出队首指针。需注意控制各个数组序号在数组长度范围之内。

Answer

2.1

//判字符串中心对称的程序代码
#include<stdio.h>
//#include<malloc.h>
#include<stdlib.h>
#include<string.h>
//定义单链表结构类型
typedef char datatype;
typedef struct node
{
    datatype data;
    struct node *next;
}linklist;
//定义顺序栈结构类型
const int maxsize=40;
typedef struct
{
    datatype elements[maxsize];
    int top;
}stack;

void setnull(stack *&);
int length(linklist*);
void printlink(linklist*);
void create(linklist *&,datatype*);
void push(stack*,datatype);
datatype pop(stack*);
int symmetry(linklist*,stack*);//判字符串是否中心对称的函数声明

int main()
{
    linklist *head;stack *s;
    datatype str[80];
    //gets(str);
    scanf("%s",str);
    create(head,str);
    printlink(head);
    setnull(s);
    if(symmetry(head,s))
        printf("字符串\"%s\"中心对称\n",str);
    else
        printf("字符串\"%s\"不是中心对称\n",str);
    return 0;
}

//栈初始化
void setnull(stack *&s)
{
    s=(stack*)malloc(sizeof(stack));
    s->top=-1;
}

//求单链表长度
int length(linklist*head)
{   linklist *p=head->next;
    int n=0;
    while(p!=NULL)
    {
        n++;
        p=p->next;
    }
    return n;
}

//输出单链表
void printlink(linklist*head)
{   linklist *p=head->next;
    while(p!=NULL)
    {   printf("%c",p->data);
        p=p->next;
    }
    printf("\n");
}

//建立具有头结点的单链表
void create(linklist *&head,datatype*str)
{   datatype *p=str;
    linklist *s,*r;
    head=(linklist*)malloc(sizeof(linklist));
    r=head;
    while(*p!='\0')
    {
        s=(linklist*)malloc(sizeof(linklist));
        s->data=*p;
        r->next=s;
        r=s;
        p++;
    }
    r->next=NULL;
}

//顺序栈入栈
void push(stack*s,datatype e)
{
    s->top++;
    s->elements[s->top]=e;
}

//顺序栈出栈
datatype pop(stack*s)
{
    datatype temp;
    s->top--;
    temp=s->elements[s->top+1];
    return temp;
}

//判字符串是否中心对称
int symmetry(linklist*head,stack*s)
{
    int l=length(head);//计算字符串长度
    linklist *p=head->next;//操作指针=首节点
    int n=0;//计数=0
    datatype e;//数据
    while(p->next!=NULL)//while(操作指针的指针域!=空) 即到字符串末尾（不算\0）
    {
        e=p->data;//数据=操作指针数据域
        n++;//计数++
        p=p->next;//操作指针=操作指针指针域
        if(n<=l/2)//如果(计数<=字符串长度一半)
            push(s,e);//数据入栈
        else if(pop(s)!=e)//否则如果(出栈数据!=数据)
            return 0;//返回0
    }
    return 1;//返回1
}

2.2

//循环队列入队出队的程序代码
#include<stdio.h>
#include<stdlib.h>
//#include<malloc.h>
//循环队列的结构类型定义
const int m=5;
typedef int datatype;
typedef struct
{   datatype sequ[m];
    int rear, quelen;
}qu;
void setnull(qu*);
void enqueue(qu*, datatype);
datatype *dequeue(qu*);

int main()
{   qu *sq;
    datatype x, *p;
    int key;
    sq=(qu*)malloc(sizeof(qu));
    setnull(sq);
    do
    {   printf("1.Enter Queue 2.Delete Queue -1.Quit:");
        scanf("%d",&key);
        switch(key)
        {   case 1: printf("Enter the Data:");
                    scanf("%d",&x);
                    enqueue(sq,x);
                    break;
            case 2: p=dequeue(sq);
                    if(p!=NULL)
                        printf("%d\n",*p);
                    break;
            case -1:exit(0);
        }
    }
    while(1);
    return 0;
}

//置空队
void setnull(qu *sq)
{   sq->rear=m-1;
    sq->quelen=0;
}

//入队
void enqueue(qu *sq,datatype x)
{
    if(sq->quelen>=m)//如果(队列长度>=数组长度)
    {
        printf("overflow\n");//拒绝入队
    }
    else
    {
        sq->sequ[sq->rear]=x;//队列数组[队尾序号]=数据
        sq->rear=(sq->rear+1)%m;//队尾序号=(队尾序号+1)%数组长度 即队尾序号加一后考虑加后队尾序号大于数组长度的情况
        sq->quelen++;//队列长度++
    }
}

//出队
datatype *dequeue(qu *sq)
{
    datatype *p=NULL;//操作指针初始化NULL
    if(sq->quelen<=0)//如果(队列长度<=0)
    {
        printf("underflow\n");//拒绝出队
    }
    else
    {
        int front=(sq->rear-sq->quelen)%m;//队首序号
        if(front<0)//如果(队首序号<0)
        {
            front+=m;//队首序号+=数组长度 即队首序号减一后考虑减后队首序号小于零的情况
        }
        p=&sq->sequ[front];//操作指针=队列数组[队首序号]
        sq->quelen--;//队列长度--
    }
    return p;//返回操作指针
}

转载于:https://www.cnblogs.com/vanlion/p/datastructure-exp-2.html