数据结构第3~4章练习答案（PTA）

单选题

2-1若栈采用顺序存储方式存储，现两栈共享空间V[1..m]，top[i]代表第i个栈( i =1,2)栈顶（该位置不存储对应栈数据），栈1的底在v[1]，栈2的底在V[m]，则栈满的条件是（B）。

A.|top[2]-top[1]|=0        B.top[1]-1=top[2]        C.top[1]+top[2]=m        D.top[1]=top[2]

2-2设有一顺序栈S，元素s1,s2,s3,s4,s5,s6依次进栈，如果6个元素出栈的顺序是s2,s3,s4, s6 , s5,s1,则栈的容量至少应该是(B)。

A.2        B.3        C.5        D.6

2-3用S表示入栈操作，X表示出栈操作，若元素入栈的顺序为1234，为了得到1342出栈顺序，相应的S和X的操作串为(D)。

A.SXSSSXXX        B.SXSXSXSX        C.SSSSXXXX        D.SXSSXSXX

2-4令P代表入栈，O代表出栈。则将一个字符串3*a+b/c变为3 a * b c / +的堆栈操作序列是哪个？（例如将ABC变成BCA的操作序列是PPOPOO。）（D）

A.PPPOOOPPOPPOOO

B.POPOPOPPOPPOOO

C.POPPOOPPOPOOPO

D.POPPOOPPOPPOOO

2-5数组A[1..n]作为栈的存储空间，栈顶top的初值为n+1,在未溢出的情况表，以下（ ）完成入栈X操作。（C）

A.top++; A[top]=X;        B.A[top]=X; top++;        C.top--; A[top]=X;        D.A[top]=X; top--;

2-6设栈S和队列Q的初始状态均为空，元素a、b、c、d、e、f、g依次进入栈S。若每个元素出栈后立即进入队列Q，且7个元素出队的顺序是b、d、c、f、e、a、g，则栈S的容量至少是（C）

A.1        B.2        C.3        D.4

2-7若top为指向栈顶元素的指针，判定栈S（最多容纳m个元素）为空的条件是（B）

A.S->top == 0 B.S->top == -1 C.S->top != m-1 D.S->top == m-1

2-8现有队列 Q 与栈 S，初始时 Q 中的元素依次是{ 1, 2, 3, 4, 5, 6 }（1在队头），S 为空。若允许下列3种操作：（1）出队并输出出队元素；（2）出队并将出队元素入栈；（3）出栈并输出出栈元素，则不能得到的输出序列是（C）

A.1, 2, 5, 6, 4, 3        B.2, 3, 4, 5, 6, 1        C.3, 4, 5, 6, 1, 2        D.6, 5, 4, 3, 2, 1

2-9若用大小为6的数组来实现循环队列，且当前front和rear的值分别为0和4。当从队列中删除两个元素，再加入两个元素后，front和rear的值分别为多少？（A）

A.2和0        B.2和2        C.2和4        D.2和6

2-10在一个不带头结点的非空链式队列中,假设f和r分别为队头和队尾指针,则删除结点的运算是(C)。

A.r=f->next;        B.r=r->next;        C.f=f->next;        D.f=r->next

2-11若用一个大小为6的数组来实现循环队列，且当前rear和fornt的值分别为0和3。从当前队列中删除一个元素，再加入两个元素后，rear和front的值分别为（B）。

A.1和5        B.2和4        C.4和2        D.5和1

2-12在一个顺序存储的循环队列中，若队尾指针指向队尾元素的后一个位置，则队头指针一般指向队头元素的（C）。

A.前一个位置        B.后一个位置        C.当前位置        D.后两个位置

2-13在少用一个元素空间的循环队列(m为最大队列长度)是满队列的条件（B）。

A.rear==front        B.(rear+1)%m==front        C.(rear+1)==front        D.front==(front+1)%m

2-14用链接方式存储的队列，在进行删除运算时（D）。

A.仅修改头指针        B.仅修改尾指针        C.头、尾指针都要修改        D.头、尾指针可能都要修改

2-15设C语言数组Data[m+1]作为循环队列SQ的存储空间， front为队头指针，rear为队尾指针，则执行出队操作的语句为(D)。

A.front=front+1

B.front=(front+1)%m 

C.rear=(rear+1)%(m+1)

D.front=(front+1)%(m+1)

2-16循环队列的队满条件为 (C)。

A.(sq.rear+1)%maxsize==(sq.front+1)%maxsize;

B.(sq.front+1)%maxsize==sq.rear

C.(sq.rear+1)%maxsize==sq.front

D.sq.rear==sq.front

2-17设有一个 10 阶的对称矩阵 A，采用压缩存储方式，以行序为主存储，a[1, 1] 为第一元素，其存储地址为 1，每个元素占一个地址空间，则 a[8, 5] 的地址为（C）。

A.13        B.32        C.33        D.40

2-18数组 A[0..5, 0..6] 的每个元素占 5 个字节，将其按列优先次序存储在起始地址为 1000 的内存单元中，则元素 A[5, 5] 的地址是(A)。

A.1175        B.1180        C.1205        D.1210

2-19设二维数组A [1.. m，1.. n]（即 m 行 n 列）按行存储在数组 B[1.. m*n]中，则二维数组元素A [i,j] 在一维数组 B 中的下标为（A）。

A.(i-1)*n+j        B.(i-1)*n+j-1        C.i*(j-1)        D.j*m+i-1

2-20若串S=“software”，其子串的个数是（B）。

A.8        B.37        C.36        D.9

程序填空题

5-1链队入队出队操作

#include
using namespace std;

#define OK 1
#define ERROR 0
typedef int Status;
typedef char QElemType;
typedef struct QNode {
    QElemType data;
    struct QNode *next;
} QNode, *QueuePtr;

typedef struct {
    QueuePtr front; 
    QueuePtr rear; 
} LinkQueue;

Status InitQueue(LinkQueue &Q) {
    Q.front = Q.rear = new QNode; 
    Q.front->next = NULL;
    return OK;
}

Status EnQueue(LinkQueue &Q, QElemType e) {
    QueuePtr p;
    p = new QNode; 
    p->data = e; 
    p->next = NULL;
    __________________; （5分）
    __________________; （5分）
    return OK;
}

Status DeQueue(LinkQueue &Q, QElemType &e) {
    QueuePtr p;
    if (Q.front == Q.rear)
        return ERROR; 
    p = Q.front->next; 
    e = p->data; 
    __________________; （5分）
    if (Q.rear == p)
        __________________; （5分）
    delete p;
    return OK;
}

int main() {
    LinkQueue Q;
    int n,m,i; 
    char c;
    InitQueue(Q);
    cin >> n;
    for(i=0;i> c;
        EnQueue(Q,c);        
    }
    for(i=0;i> m;
    for(i=0;i> c;
        EnQueue(Q,c);        
    }
    for(i=0;i

输入格式:

输入第一行为1个整数n，第二行输入n个字符，将n个字符依次入队，再执行n次出队操作（不输出）。
输入第三行为1个整数m，第四行输入m个字符，将m个字符依次入队，再执行m次出队操作并输出。

4
ABCD
5
12345

输出格式:

1 2 3 4 5 

参考答案：

（1）Q.rear->next=p
（2）Q.rear=p
（3）Q.front->next=p->next
（4）Q.rear=Q.front

函数题

6-1 顺序栈的基本运算

编写函数实现顺序栈的初始化、出栈、入栈运算。

函数接口定义：

在这里描述函数接口。例如：
Status iniStack(Sqstack &S); //初始化栈
Status push(Sqstack &S,SElemType x);//入栈
Status pop(Sqstack &S,SElemType &e);//出栈

裁判测试程序样例：

#include 
#include 
typedef int Status;
typedef char SElemType;
#define stack_INIT_SIZE     100
#define stackINCREMENT  10
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
 typedef struct {
       SElemType  *base;   //栈底指针
       SElemType  *top;     //栈顶指针
       int stacksize;       //栈空间
}Sqstack;

Status iniStack(Sqstack &S) //初始化栈
{
  /* 请在这里填写答案 */
  }//InitStack

Status push(Sqstack &S,SElemType x)
{
    /* 请在这里填写答案 */
}

Status pop(Sqstack &S,SElemType &e)
{
    /* 请在这里填写答案 */
}

Status print_stack(Sqstack S)//打印栈中元素
{
    SElemType  *p=S.base;
    while(p

输入样例：

ABCD0
2

输出样例：

出栈元素为：D
出栈元素为：C
A B 

参考答案：

Status iniStack(Sqstack &S) 
{
    S.base=new SElemType[stack_INIT_SIZE];
    if(S.base)
    {
        S.top=S.base;
        S.stacksize=stack_INIT_SIZE;
        return OK; 
    }
    else return ERROR;
}
Status push(Sqstack &S,SElemType x)
{
    if(S.top-S.base==S.stacksize) return ERROR;
    *S.top=x;
    S.top++;
    return OK;
}
Status pop(Sqstack &S,SElemType &e)
{
    if(S.top==S.base) return ERROR;
    S.top--;
    e=*S.top;
    return OK;
}

6-2 循环队列出队入队

用一个数组表示循环队列，请编写算法实现循环队列的初始化、入队和出队操作。

输入时：第一行输入队列数据空间容量，第二行依次输入5个待插入元素值，第三行再依次输入5个待插入元素值。
输出时：第一行和最后一行输出循环队列元素值及其下标（元素值（下标）），若中途出现队空或队满，则应给出相应提示。

函数接口定义：

void InitQ(SqQueue &Q,int N);
void AddQ(SqQueue &Q, int x );
Status DeleteQ(SqQueue &Q,int &e);

接口参数: Q是循环队列， N 是队列数组空间容量， x是入队元素， e用于接收出队元素的值

裁判测试程序样例：

#include 
#include 
#define OK 1
#define ERROR 0
typedef int Status;
typedef struct {
  int *base;
  int front;    //队头
  int rear;    //队尾
}SqQueue;

void InitQ(SqQueue &Q,int N);
void AddQ(SqQueue &Q, int x );
Status DeleteQ(SqQueue &Q,int &e);
void printQ(SqQueue Q);  //输出队列元素及其下标位置

int N;
int main()
{
        int x,e,i;
    SqQueue Q;
        scanf("%d",&N);     //输入循环队列空间大小  
    InitQ(Q,N);
        for(i=0;i<5;i++){     
        scanf("%d",&x);
        AddQ(Q,x);
    }
    printQ(Q);   //输出队列中的各元素
    for(i=0;i<5;i++){       
        if(DeleteQ(Q,e)==OK) printf("%d is out.\n",e); 
    }
    for(i=0;i<5;i++){  
        scanf("%d",&x);
            AddQ(Q,x);
    }
    printQ(Q);
    return 0;
}
void printQ(SqQueue Q){   
    int i;
    i=Q.front;
    while(i!=Q.rear){
         printf("%d(%d) ",Q.base[i],i);
         i=(i+1)%N;
    }
    printf("\n");
}

/* 请在这里填写答案 */

参考答案：

void InitQ(SqQueue &Q,int N)
{
    Q.base= (int*)malloc(sizeof(int)*N);
    Q.front=Q.rear=0;
}
void AddQ(SqQueue &Q, int x )
{
    if((Q.rear+1)%N==Q.front) printf("Queue Full\n");
    else
    {
        Q.base[Q.rear]=x;
        Q.rear=(Q.rear+1) % N;
    }
    
}
Status DeleteQ(SqQueue &Q,int &e)
{
    if(Q.front==Q.rear) 
    {
        printf("Queue Empty\n");
        return ERROR;
    }
    else
    {
        e=Q.base[Q.front];
        Q.front=(Q.front+1)%N;
        return OK;
    }
}