【数据结构】栈和队列

最新推荐文章于 2024-09-14 23:40:40 发布

-Rane

最新推荐文章于 2024-09-14 23:40:40 发布

阅读量662

点赞数 23

文章标签：数据结构

本文链接：https://blog.csdn.net/2302_80733101/article/details/141300341

版权

栈

栈的概念和结构

栈：一种特殊的线性表，其值允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底，栈中的元素遵循后进先出的原则

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶

出栈：栈的删除操作叫做出栈，出数据也在栈顶

栈的实现

栈的实现可以使用数组或者链表实现，相对而言数组结构实现更优秀一点。

而用链表实现的最大优点为在入栈时不需要进行扩容，本次我们就使用数组来进行栈的实现

stack.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1

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

typedef int StackDataType;
typedef struct Stack
{
	StackDataType* a;
	int top;
	int capacity;
}Stack;

void StackInit(Stack* p);
void StackDestroy(Stack* p);

void StackPush(Stack* p,StackDataType x);
void StackPop(Stack* p);

bool StackEmpty(Stack* p);
StackDataType StackTop(Stack* p);
int StackSize(Stack* p);

stack.c

#include "stack2.h"

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

void StackPush(Stack* p, StackDataType x)
{
	assert(p);
	if (p->capacity == p->top)
	{
		int newcapacity = p->capacity == 0 ? 4 : p->capacity * 2;
		StackDataType* tail = (StackDataType*)malloc(sizeof(StackDataType) * newcapacity);
		if (tail == NULL)
		{
			perror("malloc fail");
			return;
		}
		p->a = tail;
		p->capacity = newcapacity;
	}
	p->a[p->top] = x;
	p->top++;
}

void StackPop(Stack* p)
{
	assert(p);
	assert(!StackEmpty(p));
	p->top--;
}

bool StackEmpty(Stack* p)
{
	assert(p);
	return p->top == 0;
}

int StackSize(Stack* p)
{
	assert(p);
	return p->top;
}

StackDataType StackTop(Stack* p)
{
	assert(p);
	return p->a[p->top - 1];
}

void StackDestroy(Stack* p)
{
	assert(p);
	free(p->a);
	p->a = NULL;
	p->top = p->capacity = 0;
}

队列

队列的概念和结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出的特点

入队列：进行插入操作的一端称为队尾

出队列：进行删除操作的一端称为队头

队列的实现

与栈相同的是，队列也可以用数组或链表结构实现。但队列用链表结构实现更优，这里我们就用单链表来实现队列

queue.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1

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

typedef int QueueDataType;
typedef struct QListNode
{
	QueueDataType* _data;
	struct QListNode* _next;
}QNode;

typedef struct Queue
{
	QNode* _head;
	QNode* _rear;
	int _size;
}Queue;

void QueueInit(Queue* p);
void QueueDestroy(Queue* p);

void QueuePush(Queue* p,QueueDataType x);
void QueuePop(Queue* p);

int QueueSize(Queue* p);
QueueDataType QueueFront(Queue* p);
QueueDataType QueueBack(Queue* p);
bool QueueEmpty(Queu

queue.c

#include "queue2.h"

void QueueInit(Queue* p)
{
	assert(p);
	p->_head = p->_rear = NULL;
	p->_size = 0;
}

void QueuePush(Queue* p, QueueDataType x)
{
	assert(p);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->_next = NULL;
	newnode->_data = x;
	if (p->_head == NULL)
	{
		p->_head = p->_rear = newnode;
	}
	else
	{
		p->_rear->_next = newnode;
		p->_rear = newnode;
	}
	p->_size++;
}

void QueuePop(Queue* p)
{
	assert(p);
	assert(!QueueEmpty(p));
	if (p->_head == p->_rear)
	{
		p->_head = p->_rear = NULL;
	}
	else
	{
		QNode* next = p->_head->_next;
		free(p->_head);
		p->_head = next;
	}
	p->_size--;
}

bool QueueEmpty(Queue* p)
{
	return p->_size == 0;
}

int QueueSize(Queue* p)
{
	return p->_size;
}

QueueDataType QueueFront(Queue* p)
{
	assert(p);
	return p->_head->_data;
}

QueueDataType QueueType(Queue* p)
{
	assert(p);
	return p->_rear->_data;
}

void QueueDestroy(Queue* p)
{
	assert(p);
	while (!QueueEmpty(p))
	{
		QNode* next = p->_head->_next;
		free(p->_head);
		p->_head = next;
	}
	p->_size = 0;
	p->_head = p->_rear = NULL;
}

栈和队列习题

题目1：括号匹配

题目链接：20. 有效的括号 - 力扣（LeetCode）

解题思路：本题我们可以运用栈的性质来进行解答，我们首先先创建一个栈，然后依次对字符串S进行读取，若读取到的为左括号，我们则把左括号入栈；若读取到的为右括号，我们则将栈中的左括号出栈与右括号进行匹配

代码：

//因为本人用的是C语言进行编程，前面为自己写的栈，就不过多赘述了

bool isValid(char* s) {
    //定义一个栈
    Stack st;
    StackInit(&st);
    while(*s)//开始依次读取字符串
    {
        if(*s=='('||*s=='['||*s=='{')//如果读取的字符为左括号则入栈
        {
            StackPush(&st,*s);
        }
        else
        {
            //注意判断当读取字符为右括号时栈是否为空，为空的话就已经意味着括号不匹配
            if(StackEmpty(&st))
            {
                StackDestroy(&st);
                return false;
            }
            //栈不为空情况
            else
            {
                char top = StackTop(&st);//取出栈中左括号进行匹配
                StackPop(&st);
                if((*s==')'&&top!='(')||(*s==']'&&top!='[')||(*s=='}'&&top!='{'))
                {
                    return false;
                }
            }
        }
        s++;
    }
    //当读取结束时，栈内依旧有剩余左括号的话，同样也意味着括号不匹配
    if(!StackEmpty(&st))
    {
        StackDestroy(&st);
        return false;
    }
    StackDestroy(&st);
    return true;
}

题目2：用队列实现栈

题目链接：225. 用队列实现栈 - 力扣（LeetCode）

解题思路：用两个队列来实现栈的话，首先最开始的模拟入栈则随便输入一个队列q1，要模拟出栈的话先把队列q1中除最后一个元素外的其他元素输入到另一个栈q2，再返回最后一个元素。若要再模拟入栈，则将元素输入到不为空的那个队列，再模拟出栈的话则再使用上述方法。

代码：

//因为本人用C语言写代码，上方为自己写的队列在此就不多赘述
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


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

void myStackPush(MyStack* obj, int x) {
    //插入到非空的队列
    if(!QueueEmpty(&(obj->q1)))
    {
        QueuePush(&(obj->q1),x);
    }
    else
    {
        QueuePush(&(obj->q2),x);
    }
}

int myStackPop(MyStack* obj) {
    //删除的时候将非空的队列中的元素导入到另一个队列（除最后一个元素）
    Queue* noempty = &(obj->q1);
    Queue* empty = &(obj->q2);
    if(QueueEmpty(&(obj->q1)))
    {
        noempty = &(obj->q2);
        empty = &(obj->q1);
    }
    while(QueueSize(noempty)>1)
    {
        QueuePush(empty,QueueFront(noempty));
        QueuePop(noempty);
    }
    int top = QueueFront(noempty);
    QueuePop(noempty);
    return top;
}

int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&(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->q2));
    free(obj);
}

题目3：用栈实现队列

题目链接：232. 用栈实现队列 - 力扣（LeetCode）

解题思路：大体思路与上题差不多，换汤不换药，但与上题不同的是，这题两个栈的功能是固定的，一个专门用来输入，另一个专门用来输出，等用来输出的栈空了，再将用来输入的栈中的数据导入输出栈

代码：

//因为用的是C语言要自己写栈，所以省略前面部分


typedef struct {
    Stack pushst;
    Stack popst;
} MyQueue;

int myQueuePeek(MyQueue* obj);


MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&(obj->pushst));
    StackInit(&(obj->popst));
    return obj;
}

void myQueuePush(MyQueue* obj, int x) {
    StackPush(&(obj->pushst),x);
}

int myQueuePop(MyQueue* obj) {
    int top = myQueuePeek(obj);
    StackPop(&(obj->popst));
    return top;
}

int myQueuePeek(MyQueue* obj) {
    if(!STEmpty(&(obj->popst)))
    {
        return StackTop(&(obj->popst));
    }
    else
    {
        while(!STEmpty(&(obj->pushst)))
        {
            StackPush(&(obj->popst),StackTop(&(obj->pushst)));
            StackPop(&(obj->pushst));
        }
        return StackTop(&(obj->popst));
    }
    
}

bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&(obj->popst)) && STEmpty(&(obj->pushst));
}

void myQueueFree(MyQueue* obj) {
    Destroy(&(obj->pushst));
    Destroy(&(obj->popst));
    free(obj);
}

题目4：循环队列

题目链接：622. 设计循环队列 - 力扣（LeetCode）

解题思路：本题可以用数组或着链表结构来解决，这里数组更加方便，便使用数组。解决其他问题还好，重点在于如何判断队列是满状态还是空状态。这里也有两种解决方法，首先我们要设置一个头指针和一个尾指针（指向最后一个元素的下一位），第一个方法就是添加一个size变量，记录队列的长度，第二个方法就是再多加一个空间，即一开始就设置k+1个空间。除此之外，还要注意记得给变量取余，防止其超出队列长度的范围

代码：

typedef struct {
    int* a;
    int head;
    int rear;
    int k;
} MyCircularQueue;

//进行函数声明
bool myCircularQueueIsFull(MyCircularQueue* obj);
bool myCircularQueueIsEmpty(MyCircularQueue* obj);

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc(sizeof(int)*(k+1));//多建立一个空间方便后期判断队列是空是满
    obj->head=obj->rear=0;
    obj->k=k;
    return obj;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    else
    {
        obj->a[obj->rear]=value;
        obj->rear++;
        obj->rear%=obj->k+1;
        return true;
    }
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->head++;
        obj->head%=obj->k+1;
        return true;
    }
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[obj->head];
    }
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->rear==0?obj->a[obj->k]:obj->a[obj->rear-1];
    }
}

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

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->head==(obj->rear+1)%(obj->k+1);
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    obj->a=NULL;
    obj->head=obj->rear=0;
    obj->k=0;
    free(obj);
}