5.栈和队列的模拟实现以及相应习题

最新推荐文章于 2024-06-12 21:47:26 发布

the_nov

最新推荐文章于 2024-06-12 21:47:26 发布

阅读量487

点赞数 12

分类专栏：数据结构文章标签：数据结构

本文链接：https://blog.csdn.net/Q2691463021/article/details/137410325

版权

数据结构专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1.栈的模拟实现

1.1栈的概念及结构

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。**进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。**栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶。

1.2栈的模拟实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。

1.栈的结构类型声明

// stack n./stæk/ n.栈；一堆
typedef int STDataType;
typedef struct Stack
{
    // 数组地址就是a（a指向这个栈在堆上面的存储空间）
	STDataType* a;
    // top就是栈顶的下标
	int top;
    // capacity就是栈的容量
	int capacity;
}ST;               // 将这个结构体类型重新定义为ST

2.栈的初始化

void StackInit(ST* ps)
{
	assert(ps);
    // 将数组地址初始化为空（这个栈在堆上面的存储空间）
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

3.栈的销毁

void StackDestroy(ST* ps)
{
	assert(ps);
    // 销毁这个栈，首先要释放这个栈在堆上面的存储空间
	free(ps->a);
    // 为了防止野指针，将a置为空
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

4.进栈/压栈/入栈

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	// 在将一个数据入栈之前，需要先检查当前数组的容量够不够
    // 如果ps->top == ps->capacity为真，说明当前数组已经满了，如果想要继续插入，那么就需要对当前数组进行扩容
	if (ps->top == ps->capacity)
	{
        // 如果ps->capacity == 0为真，也就是数组的容量为0，那么新的容量为4
        // 如果ps->capacity == 0为假，那么数组新的容量为2倍的旧容量
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
        
        // 使用realloc函数进行扩容
        // 此处，必须将返回的地址给到tmp，而不是直接给到ps->a
        // 这是为了防止扩容失败，扩容失败，会返回空指针，那么ps->a就会变为空指针，这会造成内存泄漏
		STDataType* tmp = (STDataType*)realloc(ps->a, newCapacity*sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

        // a为扩容后数组的地址
		ps->a = tmp;
        // capacity为扩容后数组新的容量
		ps->capacity = newCapacity;
	}

    // 将x入栈
	ps->a[ps->top] = x;
	ps->top++;
}

5.检查栈是否为空

bool StackEmpty(ST* ps)
{
	assert(ps);
    // 如果ps->top == 0为真，说明栈是空的
	return ps->top == 0;
}

6.出栈

void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	
    // 出栈缩小数组的下标就可以
	--ps->top;
}

7.取栈顶元素

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	
    // 下标ps->top - 1对应的就是栈顶元素
	return ps->a[ps->top - 1];
}

8.栈的大小

int StackSize(ST* ps)
{
	assert(ps);

    // top下标对应的就是栈元素的个数
	return ps->top;
}

1.3栈的完整实现

Stack.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

typedef int 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);

STDataType StackTop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);

Stack.c

#include "Stack.h"

void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 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 = (STDataType*)realloc(ps->a, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			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;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->a[ps->top - 1];
}

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

main.c

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include "Stack.h"

// 解耦 -- 低耦合 高内聚
// 数据结构建议不要直接访问结构数据，一定要通过函数接口访问
void TestStack()
{
	ST st;
	StackInit(&st);
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	printf("%d\n", StackTop(&st));
	StackPop(&st);
	printf("%d\n", StackTop(&st));
	StackPop(&st);

	StackPush(&st, 4);
	StackPush(&st, 5);

	while (!StackEmpty(&st))
	{
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}
	printf("\n");
}

int main()
{
	TestStack();

	return 0;
}

2.队列

2.1队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 ; 出队列：进行删除操作的一端称为队头

2.2队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

1.队列的结构体声明

// 队列节点的结构体
typedef int QDataType;
typedef struct QueueNode
{
    // 指向下一个节点的指针
	struct QueueNode* next;
    // 这个节点存储的数据表
	QDataType data;
}QNode;               // 将这个结构体重新定义为QNode



//队列的结构体(封装队列的头指针和尾指针) 
typedef struct Queue
{
    // 头节点
	QNode* head; 
    // 尾节点
	QNode* tail; 
    //队列节点的数量
	int size;  
}Queue;             // 将这个结构体重新定义为Queue

2.队列的初始化

void QueueInit(Queue* pq)
{
	assert(pq);
    // 对队列的头指针，尾指针，和队列节点数量进行初始化
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

3.队列的销毁

void QueueDestroy(Queue* pq)
{
	assert(pq);
    // 从队列的头节点开始，对队列中的每一个节点进行销毁
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* del = cur;
        free(del);
        
        // 迭代
		cur = cur->next;
	}

    // 设置为空指针，防止产生野指针
	pq->head = pq->tail = NULL;
}

4.入队

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

    // 创建将要入队的新节点
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	else
	{
		newnode->data = x;
		newnode->next = NULL;
	}

    // 入队（将新节点入队，也就是在单链表中进行尾插）
	if (pq->tail == NULL)
	{
        // 当链表为空链表时，尾节点，头节点都是这个新插入的节点
		pq->head = pq->tail = newnode;
	}
	else
	{
        // 当链表不为空时
        // 1.尾节点指向这个新节点
		pq->tail->next = newnode;
        // 2.这个新节点成为新的尾节点
		pq->tail = newnode;
	}

    // 队列中的节点数量增加
	pq->size++;
}

5.检查队列是否为空

bool QueueEmpty(Queue* pq)
{
	assert(pq);

    // 当尾节点指针和头节点指针都为空，说明队列为空
	return pq->head == NULL && pq->tail == NULL;
}

6.出队

// 将一个节点出队，也就是将单链表进行头删
void QueuePop(Queue* pq)
{
	assert(pq);
    // 首先要确保这个链表不是空链表
	assert(!QueueEmpty(pq));

    // 此时，可以保证链表不是空链表
    // 那么就分为两种情况
	// 情况1：链表只剩下一个头节点，释放掉这个头节点后，需要将链表的头节点和尾节点置空
    // 情况2：链表节点的数量大于等于2，释放掉头节点之后，头节点后的节点pq->head->next成为新的头节点
	if (pq->head->next == NULL) 
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* del = pq->head;
		pq->head = pq->head->next;

		free(del);
		del = NULL;
	}

    // 链表中，节点的数量减小1个
	pq->size--;
}

7.取队头元素

// 取队头元素，也就是返回链表头节点的数据
QDataType QueueFront(Queue* pq)
{
	assert(pq);
    // 要保证链表不是空链表
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

8.取队尾元素

// 返回队尾节点的数据
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

9.队列元素的个数

// 返回链表节点的个数
int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

2.3 队列的模拟实现

Queue.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);

Queue.c

#include "Queue.h"

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* del = cur;
		cur = cur->next;
		free(del);
	}

	pq->head = pq->tail = NULL;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	else
	{
		newnode->data = x;
		newnode->next = NULL;
	}

	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;
}

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* del = pq->head;
		pq->head = pq->head->next;

		free(del);
		del = NULL;
	}

	pq->size--;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->head == NULL && pq->tail == NULL;
}

int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

main.c

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include "Queue.h"

void TestQueue()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);

	printf("%d ", QueueFront(&q));
	QueuePop(&q);
	printf("%d ", QueueFront(&q));
	QueuePop(&q);

	QueuePush(&q, 4);
	QueuePush(&q, 4);
	QueuePush(&q, 4);

	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	printf("\n");

	QueueDestroy(&q);
}

int main()
{
	TestQueue();
	return 0;
}

3.栈和队列面试题

1.括号匹配问题。OJ链接

// 自定义的栈的实现（后续可以考虑使用c++来完成这道题目，就不需要自己去写这个栈了）
// 函数声明
typedef int 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);

STDataType StackTop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);

// 函数实现
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 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 = (STDataType*)realloc(ps->a, newCapacity*sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			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;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	
	return ps->a[ps->top - 1];
}

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

bool isValid(char * s){
    // 创建一个栈对象
    ST st;
    
    // 初始化栈
    StackInit(&st);
    
    // *s为空时，说明所有的字符都已经判断过了
    while(*s)
    {
        // 1.如果是左括号，不论那种类型的左括号，就将其入栈
        if(*s == '(' || *s == '[' || *s == '{')
        {
            StackPush(&st, *s);
        }
        else
        {
            // 2.开始匹配，现在的字符对应的必然是右括号
            // 情况一：如果栈顶元素为空，说明括号数量不匹配；
            // 情况二：那么此时栈顶的元素必然是与其对应的左括号，如果不是，说明括号不匹配
            // 注：根据题目要求可知，不同类型的左右括号一一对应，且匹配顺序也是对应的
            if(StackEmpty(&st))
            {
                // 防止内存泄漏，销毁栈在堆上面开辟的空间
                StackDestroy(&st);
                // 不匹配，则返回false
                return false;
            }
            
            // 情况二
            // 取栈顶元素
            char top = StackTop(&st);
            
            // 取出之后，将其出栈，方便下一次循环，取下一个元素
            StackPop(&st);
            
            // 这三个条件，满足一个，则说明不匹配，返回false
            if(( *s == ')' && top != '(' )
            || ( *s == ']' && top != '[' )
            || ( *s == '}' && top != '{' ))
            {
                // 防止内存泄漏，销毁栈在堆上面开辟的空间
                StackDestroy(&st);
                // 不匹配，则返回false
                return false;
            }
        }
        
        // 迭代
        // 字符串到'\0'停止 
        ++s; 
    }

    // 将右括号与栈里面的左括号匹配之后，如果栈里面还有左括号，说明括号数量不匹配
    // 如果栈为空，说明匹配正确，返回真
    // 则flag为真，否则为假
    bool flag = StackEmpty(&st);  

    // 最后要将栈销毁，防止内存泄漏
    StackDestroy(&st);

    return flag;
}

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

// 自定义的栈的实现（后续可以考虑使用c++来完成这道题目，就不需要自己去写这个栈了）
// 函数声明
typedef int 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);

STDataType StackTop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);

// 函数实现
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 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 = (STDataType*)realloc(ps->a, newCapacity*sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			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;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	
	return ps->a[ps->top - 1];
}

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

// 用两个队列，实现一个先入后出的栈

// 匿名类型结构体，只能够使用一次
typedef struct {  
    // 1号队列
    Queue q1;
    // 2号队列
    Queue q2;
} MyStack;


// 创建一个栈对象
MyStack* myStackCreate() {
    // 申请存放两个队列变量的空间；object n.目标，对象
    // obj必须在堆上面申请空间，如果在栈区上面，出了局部作用域队列空间就会被销毁
    
    // 使用malloc申请一个栈对象大小的空间，并返回这个空间的地址给到obj
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));

    // 初始化两个队列
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);

    // 返回栈对象的地址
    return obj;
}

// 栈对象的插入功能
void myStackPush(MyStack* obj, int x) {
    
    // 将数据压栈到非空的队列
    // 第一次压栈，因为两个队列都是空队列，所以会压栈道队列2中
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1, x);
    }
    else
    {
        QueuePush(&obj->q2, x);
    }

}

// 栈的出栈功能
int myStackPop(MyStack* obj) {
    // 将非空队列中的前（n-1）个数据出队，放入另一个空队列，再将剩余的唯一数据出队
    
    // 步骤1：假设q1是空队列，q2是非空队列
    Queue* Empty = &obj->q1;      
    Queue* nonEmpty = &obj->q2;
    // 如果!QueueEmpty(&obj->q1)为真，说明假设错误
    if(!QueueEmpty(&obj->q1))
    {
        Empty = &obj->q2;
        nonEmpty = &obj->q1;
    }
    // 此时Empty必然是空队列，nonEmpty必然是非空队列
    

    // 步骤2：将非空队列中的前（n-1）个数据出队，放入另一个空队列
    // 非空队列中节点数量还大于1，则循环继续
    while(QueueSize(nonEmpty) > 1)        
    {
        // 通过QueueFront(nonEmpty)，取非空队列的头节点
        // 通过QueuePush()将非空队列的头节点，放入道空队列中（入队到空队列）
        QueuePush(Empty,QueueFront(nonEmpty));
        // 将非空队列的头节点出队
        QueuePop(nonEmpty);
    }

    // 再将剩余的一个数据出队，并将其返回（对应栈的出栈）
    int top = QueueFront(nonEmpty);
    QueuePop(nonEmpty);
    return top;
}

// 拿到栈顶元素
int myStackTop(MyStack* obj) {
    // 栈顶元素，就是非空队列尾节点的数据
    // 将非空队列tail指向的数据返回
    if(!QueueEmpty(&obj->q1))
    {
        // 通过QueueBack(&obj->q1)取尾节点的数据
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

// 判断栈是否为空
bool myStackEmpty(MyStack* obj) {
    // 当两个队列都为空时，栈为空
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);

}

// 释放栈空间
void myStackFree(MyStack* obj) {
    // 先释放申请的两个队列的空间
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q1);

    // 再释放存放两个队列变量的空间
    free(obj);

}

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

// 自定义的栈的实现（后续可以考虑使用c++来完成这道题目，就不需要自己去写这个栈了）
// 函数声明
typedef int 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);

STDataType StackTop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);

// 函数实现
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 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 = (STDataType*)realloc(ps->a, newCapacity*sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			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;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	
	return ps->a[ps->top - 1];
}

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

typedef struct {
   // 将两个栈的变量用封装成队列的结构体
   ST PushST;
   ST PopST;

} MyQueue;


MyQueue* myQueueCreate() {
     // 申请空间来存放两个栈的变量
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));

    // 将两个栈初始化
    StackInit(&obj->PushST);
    StackInit(&obj->PopST);

    // 返回申请的队列的地址
    return obj;
}

void myQueuePush(MyQueue* obj, int x) {
    // 入队，也就是将数据全部压栈到PushST
    StackPush(&obj->PushST, x);

}

// 由于出队和取队顶元素，都需要检查PopST是否为空栈，
// 如果为空栈，需要将PushST的数据导入到PopST
// 因此单独写一个函数来封装
void PushSTToPopST(MyQueue* obj)
{
    if(StackEmpty(&obj->PopST))
    {
        while(!StackEmpty(&obj->PushST))
        {
            // 将PushST的数据导入PopST之后，PushST也要将其出栈
            StackPush(&obj->PopST, StackTop(&obj->PushST));
            StackPop(&obj->PushST);
        }
    }
    
}

int myQueuePop(MyQueue* obj) {
    // 先判断是否需要导数据
    PushSTToPopST(obj);
     
    // 出队也就是PopST出栈
    int front = StackTop(&obj->PopST);
    StackPop(&obj->PopST);
    return front;

}

int myQueuePeek(MyQueue* obj) {
    // 先判断是否需要导数据
    PushSTToPopST(obj);
    
    // 取队头数据，也就是取PopST的栈顶数据
    return StackTop(&obj->PopST);

}

bool myQueueEmpty(MyQueue* obj) {
    // 队列为空，也就是两个栈都为空
    return StackEmpty(&obj->PushST) && StackEmpty(&obj->PopST);

}

void myQueueFree(MyQueue* obj) {
    // 先释放两个栈申请的空间
    StackDestroy(&obj->PushST);
    StackDestroy(&obj->PopST);

    // 在释放存放栈的变量的空间
    free(obj);
}

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

// 循环队列的结构体
typedef struct {
    // a是指向循环列队在堆上开辟空间的指针
    int* a;
    // front是队列的队头的下标
    int front;
    // rear n.后部，背部 
    // rear是队列尾元素的下一个元素的下标
    // 注：rear所在的空间，是不存储数据的，只是用来判断队列是否满了
    int rear;
    // 队列空间的个数
    int N ;
} MyCircularQueue;


// 创建循环队列（并进行初始化）
MyCircularQueue* myCircularQueueCreate(int k) {
    // 创建一个循环队列对象大小的空间，并返回这个空间的地址
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));

    // 再申请存放队列的空间，需要在固定队列长度的基础上再多开一个空间
    obj->N = k + 1;
    obj->front = obj->rear = 0;
    // 队列的大小为obj->N个int大小的空间
    obj->a = (int*)malloc(sizeof(int)*obj->N);

    // 返回循环队列
    return obj;
}

// 判断循环队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    // 当front == rear为真时，队列为空
    return obj->front == obj->rear;
}

// 判断循环队列是否满了
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    // 方案1：当(rear+1)%N == front时，队列已满
    return (obj->rear+1) % obj->N == obj->front;

    /*
    // 方案2：单独处理rear == k的情况
    if(obj->rear == obj->N - 1)
    {
        return obj->front == 0;
    }
    else
    {
        return obj->rear + 1 == obj->front;
    }
    */
}

// 循环队列入队
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    // 第一步：先检查队列是否已满
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }

    // 第二步：在rear处，插入并更新rear
    obj->a[obj->rear] = value;
    obj->rear = (obj->rear + 1) % obj->N;
    return true;
}

// 循环队列出队
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    // 第一步：先检查队列是否为空
    if(myCircularQueueIsEmpty(obj))
        return false;

    // 第二步：将front位置处的数据出队，并更新front
    obj->front = (obj->front+1) % obj->N;
    return true;
}

// 取队列的队头元素
int myCircularQueueFront(MyCircularQueue* obj) {
    // 取队首元素，也就是取front位置处的元素
    // 第一步：检查队列是否为空
    if(myCircularQueueIsEmpty(obj))
        return -1;

    // 第二步：取队头元素返回
    return obj->a[obj->front];

}

// 取队列的队尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
    // 取队尾元素也就是取rear前一个位置的元素
    // 第一步：检查队列是否为空
    if(myCircularQueueIsEmpty(obj))
        return -1;

    // 第二步：取队尾元素，并返回
    return obj->a[(obj->rear - 1 + obj->N) % obj->N];

}

// 释放循环队列
void myCircularQueueFree(MyCircularQueue* obj) {
    // 先释放队列的空间
    free(obj->a);
    obj->a =NULL;

    // 再释放存放队列变量的空间
    free(obj);
}

4.概念选择题

1.一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出栈的顺序是（ ）。
A 12345ABCDE
B EDCBA54321
C ABCDE12345
D 54321EDCBA

2.若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）
A 1,4,3,2
B 2,3,4,1
C 3,1,4,2
D 3,4,2,1
    
    
选项A:入栈1，出栈1；入栈2,3,4 出栈4,3,2
选项B：入栈1,2；出栈2，入栈3，出栈3，入栈4，出栈4，再出栈1；
选项D：入栈1,2,3；出栈3，入栈4，出栈4，再出栈1,2；

3.循环队列的存储空间为 Q(1:100) ，初始状态为 front=rear=100 。经过一系列正常的入队与退队操作后， front=rear=99 ，则循环队列中的元素个数为（ ）
A 1
B 2
C 99
D 0或者100

4.以下( )不是队列的基本运算？
A 从队尾插入一个新元素
B 从队列中删除第i个元素
C 判断一个队列是否为空
D 读取队头元素的值

5.现有一循环队列，其队头指针为front，队尾指针为rear；循环队列长度为N（也就是队列有N个空间）。其队内有效长度为？(假设队尾的空间不存放数据)
A (rear - front + N) % N + 1
B (rear - front + N) % N
C ear - front) % (N + 1)
D (rear - front + N) % (N - 1)

答案：
1.B
2.C
3.D
4.B
5.B

the_nov

关注

12
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
5.栈和队列的模拟实现以及相应习题

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。**进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。**栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。压栈：栈的插入操作叫做进栈/压栈/入栈，。出栈：栈的删除操作叫做出栈。。
复制链接

扫一扫