＜栈和队列＞题目练习《数据结构(C语言版)》

目录

题目：

【单选题】

1.下列关于栈的叙述正确的是（ ）

 2.一个栈的入栈序列为ABCDE，则不可能的出栈序列为（ ）

3.链栈与顺序栈相比，比较明显的优点是（ ）

4.下列关于队列的叙述错误的是（ ）

5.用无头单链表存储队列，其头指针指向队头结点，尾指针指向队尾结点，则在进行出队操作时（ ）

 6.以下不是队列的基本运算的是（ ）

7.下面关于栈和队列的说法中错误的是（ ）

8.下列关于用栈实现队列的说法中错误的是（ ）

9.现有一循环队列，其队头指针为front，队尾指针为rear，循环队列长度为N,最多存储N-1个数据。其队内有效长度为（ ）

10.下列关于循环队列的说法，正确的是（ ）

【编程题】

11.有效的括号

12.用队列实现栈。OJ链接 

13.用栈实现队列。OJ链接

14.设计循环队列。OJ链接

15.栈和队列的实现

解析：

后记：●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！

                                                                           ——By 作者：新晓·故知

题目：

【单选题】

1.下列关于栈的叙述正确的是（ ）

A.栈是一种“先进先出”的数据结构

B.栈可以使用链表或顺序表来实现

C.栈只能在栈底插入数据

D.栈不能删除数据

 2.一个栈的入栈序列为ABCDE，则不可能的出栈序列为（ ）

A.ABCDE

B.EDCBA

C.DCEBA

D.ECDBA

3.链栈与顺序栈相比，比较明显的优点是（ ）

A.插入操作更加方便

B.删除操作更加方便

C.无需扩展空间大小

D.无需缩小空间大小

4.下列关于队列的叙述错误的是（ ）

A.队列可以使用链表实现

B.队列是一种“先入先出”的数据结构

C.数据出队列时一定只影响尾指针

D.数据入队列时一定从尾部插入

5.用无头单链表存储队列，其头指针指向队头结点，尾指针指向队尾结点，则在进行出队操作时（ ）

A.仅修改队头指针

B.队头、队尾指针都要修改

C.队头、队尾指针都可能要修改

D.仅修改队尾指针

 6.以下不是队列的基本运算的是（ ）

A.从队尾插入一个新元素

B.从队列中删除队尾元素

C.判断一个队列是否为空

D.读取队头元素的值

7.下面关于栈和队列的说法中错误的是（ ）

A.队列和栈通常都使用链表实现

B.队列和栈都只能从两端插入、删除数据

C.队列和栈都不支持随机访问和随机插入

D.队列是“先入先出”，栈是“先入后出”

8.下列关于用栈实现队列的说法中错误的是（ ）

A.用栈模拟实现队列可以使用两个栈，一个栈模拟入队列，一个栈模拟出队列

B.每次出队列时，都需要将一个栈中的全部元素导入到另一个栈中，然后出栈即可

C.入队列时，将元素直接往模拟入队列的栈中存放即可

D.入队列操作时间复杂度为O(1)

9.现有一循环队列，其队头指针为front，队尾指针为rear，循环队列长度为N,最多存储N-1个数据。其队内有效长度为（ ）

A.(rear - front + N) % N + 1

B.(rear - front + N) % N

C.(rear - front) % (N + 1)

D.(rear - front + N) % (N - 1)

10.下列关于循环队列的说法，正确的是（ ）

A.循环队列的长度通常都不固定

B.循环队列通常使用链表模拟

C.用队头和队尾是否在同一个位置并不能判断循环对垒是否为空或者满

D.循环队列是一种非线性数据结构

【编程题】

11.有效的括号

括号匹配问题。OJ链接

12.用队列实现栈。OJ链接 

13.用栈实现队列。OJ链接

14.设计循环队列。OJ链接

15.栈和队列的实现

解析：

1.答案：B

解析：栈是一种线性结构，任何线性表都可以用来实现栈，只是实现方式有所差异。栈后进先出，只能在栈顶进行插入和删除操作。

2.答案：D

​解析：如果是E先出，说明所有的元素都已经全部入栈，此时C不可能先于D出栈。

3.答案：C

解析：选项A中，如果是链栈，一般需要进行头插操作，而顺序栈一般进行尾插操作，此时顺序栈的操作更方便。

选项B中，类似于A，链栈进行头删，顺序栈进行尾删，仍然是顺序栈更方便

选项D中，删除操作，链栈需要释放空间，会有空间的缩小

选项C中，如果是顺序栈，插入元素要考虑增容问题，但是链栈不需要考虑增容，链栈每插入一个元素就对对应开辟一个元素的空间。

4.答案：C

解析：出队操作，一定会影响头指针，如果出队之后，队列为空，会影响尾指针。

5.答案：C

解析：出队操作，一定会修改头指针，如果出队之后，队列为空，需要修改尾指针。

6.答案：B

解析：队列只能从队头删除元素。

7.答案：AB

解析：顺序表的结构相比链表简单，不影响效率的情况下会优先使用顺序表。所以栈一般用顺序表实现，队列一般用链表实现。栈只能在一端插入和删除数据。

8.答案：B

解析：选项B中，一个栈模拟入队列，一个栈模拟出队列，出队列时直接弹出模拟出队列栈的栈顶元素，当该栈为空时，将模拟入队列栈中所有元素导入即可，不是每次都需要导入元素，故错误

选项A中，栈和队列的特性是相反的，一个栈实现不了队列

选项C中，一个栈模拟入队列，一个栈模拟出队列，入队列时，将元素直接往模拟入队列的栈中存放

选项D中，入队列就是将元素放到栈中，因此时间复杂度就是O(1)

9.

10.答案：B

解析： 有效长度一般是rear-front, 但是循环队列中rear有可能小于front，所以需要+N，最大长度为N，所以有效长度不可能超过N，故需要%N。

11.

typedef char STDatatype;
typedef struct Stack
{
    STDatatype* a;
    int top;        // 栈顶
    int capacity;
}ST;
 
 
void StackInit(ST* ps);
void StackDestroy(ST* ps);
void StackPush(ST* ps, STDatatype x);
void StackPop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);
STDatatype StackTop(ST* ps);
 
 
void StackInit(ST* ps)
{
    assert(ps);
    ps->a = NULL;
    ps->top = 0; // -1
    ps->capacity = 0;
}
 
 
void StackDestroy(ST* ps)
{
    assert(ps);
    if (ps->a)
    {
        free(ps->a);
    }
    ps->a = NULL;
    ps->top = 0; 
    ps->capacity = 0;
}
 
 
void StackPush(ST* ps, STDatatype x)
{
    assert(ps);
 
 
    // 检查空间够不够，不够就增容
    if (ps->top == ps->capacity)
    {
        int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
        STDatatype* tmp = realloc(ps->a, sizeof(STDatatype)*newcapacity);
        if (tmp == NULL)
        {
            printf("rellaoc failn");
            exit(-1);
        }
        ps->a = tmp;
        ps->capacity = newcapacity;
    }
 
 
    ps->a[ps->top] = x;
    ps->top++;
}
 
 
void StackPop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));
 
 
    --ps->top;
}
 
 
bool StackEmpty(ST* ps)
{
    assert(ps);
 
 
    return ps->top == 0;
}
 
 
int StackSize(ST* ps)
{
    assert(ps);
 
 
    return ps->top;
}
 
 
STDatatype StackTop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));
 
 
    return ps->a[ps->top - 1];
}
 
 
bool isValid(char * s){
    ST st;
    StackInit(&st);
    bool match = true;
    while(*s)
    {
        if(*s == '[' || *s == '(' || *s == '{')
        {
            StackPush(&st, *s);
            ++s;
        }
        else
        {
            if(StackEmpty(&st))
            {
                match = false;
                break;
            }
 
 
            char ch = StackTop(&st);
            StackPop(&st);
            if((*s == ']' && ch != '[')
            || (*s == '}' && ch != '{')
            || (*s == ')' && ch != '('))
            {
                match = false;
                break;
            }
            else
            {
                ++s;
            }
        }
    }
 
 
    if(match == true)
    {
        match = StackEmpty(&st);
    }
 
 
    StackDestroy(&st);
    
    return match;
}

12.

typedef struct {
    Queue q1;
    Queue q2;
    
} MyStack;
 

MyStack* myStackCreate(int maxSize) {
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&pst->q1);
    QueueInit(&pst->q2);
        
    return pst;
}
 

void myStackPush(MyStack* obj, int x) {
    //给非空队列进行入队操作
    if(QueueEmpty(&obj->q1) != 0)
    {
        QueuePush(&obj->q1, x);
    }
    else
    {
        QueuePush(&obj->q2, x);
    }
}
 

int myStackPop(MyStack* obj) {
    //把非空队列的除最后一个元素之外的剩余元素全部入队空队列
    Queue* pEmpty = &obj->q1, *pNonEmpty = &obj->q2;
    if(QueueEmpty(&obj->q1) != 0)
    {
        pEmpty = &obj->q2;
        pNonEmpty = &obj->q1;
    }
    
    while(QueueSize(pNonEmpty) > 1)
    {
        QueuePush(pEmpty, QueueFront(pNonEmpty));
        QueuePop(pNonEmpty);
    }
    
    int top = QueueFront(pNonEmpty);
    //队尾元素出队
    QueuePop(pNonEmpty);
    
    return top;
}
 

int myStackTop(MyStack* obj) {
    //获取非空队列的队尾元素
    Queue* pEmpty = &obj->q1, *pNonEmpty = &obj->q2;
    if(QueueEmpty(&obj->q1) != 0)
    {
        pEmpty = &obj->q2;
        pNonEmpty = &obj->q1;
    }
    
    return QueueBack(pNonEmpty);
}
 

bool myStackEmpty(MyStack* obj) {
    return !(QueueEmpty(&obj->q1) | QueueEmpty(&obj->q2));
}
 
void myStackFree(MyStack* obj) {
    QueueDestory(&obj->q1);
    QueueDestory(&obj->q2);
    free(obj);
}

13.

typedef struct {
    //入队栈
    Stack pushST;
    //出队栈
    Stack popST;
} MyQueue;
 

MyQueue* myQueueCreate(int maxSize) {
    MyQueue* pqueue = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&pqueue->pushST, maxSize);
    StackInit(&pqueue->popST, maxSize);
    return pqueue;
}
 

void myQueuePush(MyQueue* obj, int x) {
    //入队栈进行入栈操作
    StackPush(&obj->pushST, x);
}
 

int myQueuePop(MyQueue* obj) {
    //如果出队栈为空，导入入队栈的元素
    if(StackEmpty(&obj->popST) == 0)
    {
        while(StackEmpty(&obj->pushST) != 0)
        {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    
    int front = StackTop(&obj->popST);
    //出队栈进行出队操作
    StackPop(&obj->popST);
    return front;
}
 

int myQueuePeek(MyQueue* obj) {
    //类似于出队操作
    if(StackEmpty(&obj->popST) == 0)
    {
        while(StackEmpty(&obj->pushST) != 0)
        {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    
    return StackTop(&obj->popST);
}
 

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->pushST) == 0
        &&  StackEmpty(&obj->popST) == 0;
}
 
void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->pushST);
    StackDestroy(&obj->popST);
    
    free(obj);
}

14.

typedef struct {
    int* queue;
    int front;
    int rear;
    int k
} MyCircularQueue;
 

//创建一个可以存放k个元素的循环队列，实际申请的空间为k + 1
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* pcq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    pcq->queue = (int*)malloc(sizeof(int)*(k+1));
    pcq->front = 0;
    pcq->rear = 0;
    pcq->k = k;
    
    return pcq;
}
 

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    //判满
    if((obj->rear+1)%(obj->k+1) == obj->front)
    {
        return false;
    }
    //队尾入队
    obj->queue[obj->rear++] = value;
    //如果队尾越界，更新为最小值
    if(obj->rear == obj->k+1)
        obj->rear = 0;
    
    return true;
}
 

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    //判空
    if(obj->front == obj->rear)
        return false;
    //队头出队
    ++obj->front;
    //如果队头越界，更新为最小值
    if(obj->front == obj->k+1)
        obj->front = 0;
    
    return true;
}
 

int myCircularQueueFront(MyCircularQueue* obj) {
    if(obj->front == obj->rear)
        return -1;
    else
        return obj->queue[obj->front];
}
 

int myCircularQueueRear(MyCircularQueue* obj) {
     if(obj->front == obj->rear)
        return -1;
    //队尾元素再rear索引的前一个位置，如果rear为0，
    //则队尾元素在数组的最后一个位置
    if(obj->rear == 0)
        return obj->queue[obj->k];
    else
        return obj->queue[obj->rear-1];
}
 

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front == obj->rear;
}
 

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->rear+1)%(obj->k+1) == obj->front;
}
 
void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->queue);
    free(obj);
}

15.

// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;
// 初始化栈 
void StackInit(Stack* ps); 
// 入栈 
void StackPush(Stack* ps, STDataType data); 
// 出栈 
void StackPop(Stack* ps); 
// 获取栈顶元素 
STDataType StackTop(Stack* ps); 
// 获取栈中有效元素个数 
int StackSize(Stack* ps); 
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps); 
// 销毁栈 
void StackDestroy(Stack* ps); 

// 链式结构：表示队列 
typedef struct QListNode 
{ 
	struct QListNode* _next; 
	QDataType _data; 
}QNode; 
 
// 队列的结构 
typedef struct Queue 
{ 
	QNode* _front; 
	QNode* _rear; 
}Queue; 
 
// 初始化队列 
void QueueInit(Queue* q); 
// 队尾入队列 
void QueuePush(Queue* q, QDataType data); 
// 队头出队列 
void QueuePop(Queue* q); 
// 获取队列头部元素 
QDataType QueueFront(Queue* q); 
// 获取队列队尾元素 
QDataType QueueBack(Queue* q); 
// 获取队列中有效元素个数 
int QueueSize(Queue* q); 
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q); 
// 销毁队列 
void QueueDestroy(Queue* q);

#include "stack.h"
#define DEFSTACKSIZE 100
 
void CheckCapacity(Stack* ps)
{
	if (ps->size >= ps->capacity)
	{
		ps->capacity *= 2;
		ps->array = (STDataType *)realloc(ps->array, ps->capacity * sizeof(STDataType));
	}
}
 
void StackInit(Stack* ps)
{
	ps->array = (STDataType *)calloc(DEFSTACKSIZE, sizeof(STDataType));
	ps->capacity = DEFSTACKSIZE;
	ps->size = 0;
}
 
void StackPush(Stack* ps, STDataType x)
{
	CheckCapacity(ps);
 
	ps->array[ps->size] = x;
	ps->size++;
}
 
void StackPop(Stack* ps)
{
	if (ps->size == 0)
	{
		return;
	}
	ps->size--;
}
 
STDataType StackTop(Stack* ps)
{
	if (ps->size == 0)
	{
		return (STDataType)0;
	}
	return ps->array[ps->size - 1];
}
 
int StackEmpty(Stack* ps)
{
	return ps->size == 0;
}
 
int StackSize(Stack* ps)
{
	return ps->size;
}
 
void StackDestory(Stack* ps)
{
	if (ps->array)
	{ 
		free(ps->array);
		ps->array = NULL;
		ps->size = 0;
		ps->capacity = 0;
	}
}

#include "queue.h"
 
QueueNode * BuyQueueNode(QuDataType x)
{
	QueueNode * cur = (QueueNode *)malloc(sizeof(QueueNode));
	cur->_data = x;
	cur->_next = NULL;
	return cur;
}
 
void QueueInit(Queue* q)
{
	q->_front = NULL;
	q->_rear = NULL;
}
 
void QueuePush(Queue* q, QuDataType x)
{
	QueueNode * cur = BuyQueueNode(x);
 
	if (q->_front == NULL)
	{
		q->_front = q->_rear = cur;
	}
	else
	{
		q->_rear->_next = cur;
		q->_rear = cur;
	}
}
 
void QueuePop(Queue* q)
{
	if (q->_front == NULL)
	{
		return;
	}
	QueueNode* tmp = q->_front->_next;
	free(q->_front);
	q->_front = tmp;
}
 
QuDataType QueueFront(Queue* q)
{
	return q->_front->_data;
}
 
QuDataType QueueBack(Queue* q)
{
	return q->_rear->_data;
}
 
int QueueEmpty(Queue* q)
{
	return q->_front == NULL;
}
 
int QueueSize(Queue* q)
{
    QListNode * cur;
    int count = 0;
	for (cur = q->_front; cur; cur = cur->_next)
    {
        count++;
    }
    return count;
}
 
void QueueDestory(Queue* q)
{
	if (q->_front == NULL)
	{
		return;
	}
 
	while (q->_front)
	{
		QueuePop(q);
	}
}

后记：
●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！

                                                                           ——By 作者：新晓·故知