数据结构栈和队列

最新推荐文章于 2024-07-13 17:12:41 发布

WhiteShirtI

最新推荐文章于 2024-07-13 17:12:41 发布

阅读量558

点赞数 4

分类专栏：数据结构文章标签：队列堆栈数据结构

本文链接：https://blog.csdn.net/qq_44443986/article/details/111475554

版权

数据结构专栏收录该内容

13 篇文章 16 订阅

订阅专栏

栈和队列

栈
队列
栈和队列的应用举例

栈

栈又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则——后进先出

栈的结构

在这里插入图片描述
栈有两种存储结构1、顺序表（连续结构）2、带头循环双向链表（非连续结构）
1、连续结构
入栈：尾插(O(1)) / 头插(O(n))
出栈：尾删(O(1)) / 头删(O(n))
2、非连续结构
入栈：尾插(O(1)) / 头插(O(1))
出栈：尾删(O(1)) / 头删(O(1))

正因为栈被限定于只能在结构的尾部操作，可以看出连续结构和非连续结构的尾插和尾删都是O(1)的操作。这里我们首选顺序表来实现栈

栈的操作

栈被限定只能进行尾删和尾插，这里我们主要是用顺序表来实现栈

栈操作的接口

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int STDataType;

typedef struct Stack {
	STDataType* _a;
	int _top;// 栈顶
	int _capacity; // 容量
}Stack;

// 初始化栈 
void StackInit(Stack* ps);

//检查容量
void CheckCapacity(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);

栈的操作接口实现

#include"stack.h"

// 初始化栈 
void StackInit(Stack* ps)
{
	ps->_a = NULL;
	ps->_top = 0;
	ps->_capacity = 0;
}

//检查容量
void CheckCapacity(Stack* ps)
{
	if (ps->_top == ps->_capacity)
	{
		size_t newCapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		ps->_a = (STDataType*)realloc(ps->_a, newCapacity * sizeof(STDataType));
		if (!ps->_a)
			return;
			ps->_capacity = newCapacity;
	}
}

// 入栈
void StackPush(Stack* ps, STDataType data)
{
	CheckCapacity(ps);
	ps->_a[ps->_top++] = data;

}

// 出栈 
void StackPop(Stack* ps)
{
	assert(ps && ps->_top > 0);
	--ps->_top;
}

// 获取栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);
	return ps->_a[ps->_top - 1];
}

// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->_top == 0 ? 1 : 0;
}

// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = ps->_top = 0;
}

队列

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中的数据元素遵守先进先出LIFO（First In First Out）的原则——先进先出

队列的结构

在这里插入图片描述

队列有两种存储结构1、顺序表（连续结构）2、带头循环双向链表（非连续结构）
1、连续结构
入队：尾插(O(1)) / 头插(O(1))
出队：尾删(O(1)) / 头删(O(1))
2、非连续结构
入队：尾插(O(1)) / 头插(O(1))
出队：尾删(O(1)) / 头删(O(1))
而我们最常用得是带尾结点的非循环单链表
入队：尾插(O(1))
出队：头删(O(1))

队列的操作

队列的操作接口

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

typedef int QDataType;

typedef struct QueueNode
{
	QDataType _data;
	struct QueueNode* _next;
}QueueNode;

typedef struct Queue
{
	struct QueueNode* _front;
	struct QueueNode* _back;
}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"queue.h"

// 初始化队列 
void QueueInit(Queue* q)
{
	assert(q);
	q->_front = q->_back = NULL;
}

// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
	assert(newNode);
	newNode->_data = data;
	newNode->_next = NULL;

	if (q->_back == NULL)
	{
		q->_front = q->_back = newNode;
	}
	else
	{
		q->_back->_next = newNode;
		q->_back = newNode;
	}
}
// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	if (q->_front->_next == NULL)
	{
		free(q->_front);
		q->_front = q->_back = NULL;
	}
	else
	{
		QueueNode* second = q->_front->_next;
		free(q->_front);
		q->_front = second;
	}
	
}
// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	return q->_front->_data;
}
// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	return q->_back->_data;
}
// 获取队列中有效元素个数
int QueueSize(Queue* q)
{
	int count = 0;
	QueueNode* cur = q->_front;
	while (cur)
	{
		++count;
		cur = cur->_next;
	}
	return count;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	return q->_front == NULL ? 1 : 0;
}
// 销毁队列 
void QueueDestroy(Queue* q)
{
	QueueNode* cur = q->_front;
	while (cur)
	{
		QueueNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	q->_back = q->_front = NULL;
}

栈和队列的应用举例

在笔试面试中，常考栈和队列的有关问题：1、括号匹配问题 2、用队列实现栈 3、用栈实现队列 4、设计循环队列
1、括号匹配问题
question1：给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
在这里插入图片描述

typedef char STDataType;

typedef struct Stack {
	STDataType* _a;
	int _top;// 栈顶
	int _capacity; // 容量
}Stack;

// 初始化栈 
void StackInit(Stack* ps)
{
	ps->_a = NULL;
	ps->_top = 0;
	ps->_capacity = 0;
}

//检查容量
void CheckCapacity(Stack* ps)
{
	if (ps->_top == ps->_capacity)
	{
		size_t newCapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		ps->_a = (STDataType*)realloc(ps->_a, newCapacity * sizeof(STDataType));
		if (ps->_a)
			ps->_capacity = newCapacity;
	}
}

// 入栈
void StackPush(Stack* ps, STDataType data)
{
	CheckCapacity(ps);
	ps->_a[ps->_top++] = data;

}

// 出栈 
void StackPop(Stack* ps)
{
	assert(ps && ps->_top > 0);
	--ps->_top;
}

// 获取栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);
	return ps->_a[ps->_top - 1];
}


// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->_top == 0 ? 1 : 0;
}

// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = ps->_top = 0;
}


bool isValid(char * s)
{
    Stack st;
    StackInit(&st);
    char* symbols[] = {"[]","{}","()"};

    while(*s)
    {
        if(*s == '{' || *s == '(' || *s == '[')
        {
            StackPush(&st, *s);
        }
        else 
        {
            if(StackEmpty(&st))
                return false;
                char top = StackTop(&st);
                StackPop(&st);
            for(int i = 0; i < 3; ++i)
            {
                if(*s == symbols[i][1] && top != symbols[i][0])er
                    return false;
            }
        }
        ++s;
    }
    bool ret = StackEmpty(&st);
    StackDestroy(&st);
    return ret;
}

2、用队列实现栈
question2:使用队列实现栈的下列操作：
push(x) – 元素 x 入栈
pop() – 移除栈顶元素
top() – 获取栈顶元素
empty() – 返回栈是否为空
在这里插入图片描述

typedef int QDataType;

typedef struct QueueNode
{
	QDataType _data;
	struct QueueNode* _next;
}QueueNode;

typedef struct Queue
{
	struct QueueNode* _front;
	struct QueueNode* _back;
}Queue;

// 初始化队列 
void QueueInit(Queue* q)
{
	assert(q);
	q->_front = q->_back = NULL;
}

// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
	assert(newNode);
	newNode->_data = data;
	newNode->_next = NULL;

	if (q->_back == NULL)
	{
		q->_front = q->_back = newNode;
	}
	else
	{
		q->_back->_next = newNode;
		q->_back = newNode;
	}
}
// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	if (q->_front->_next == NULL)
	{
		free(q->_front);
		q->_front = q->_back = NULL;
	}
	else
	{
		QueueNode* second = q->_front->_next;
		free(q->_front);
		q->_front = second;
	}
	
}
// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	return q->_front->_data;
}
// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	return q->_back->_data;
}
// 获取队列中有效元素个数
int QueueSize(Queue* q)
{
	int count = 0;
	QueueNode* cur = q->_front;
	while (cur)
	{
		++count;
		cur = cur->_next;
	}
	return count;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	return q->_front == NULL ? 1 : 0;
}
// 销毁队列 
void QueueDestroy(Queue* q)
{
	QueueNode* cur = q->_front;
	while (cur)
	{
		QueueNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	q->_back = q->_front = NULL;
}

typedef struct {
   struct Queue _q1;
   struct Queue _q2;
} MyStack;

/** Initialize your data structure here. */

MyStack* myStackCreate() {
    MyStack * st = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&st->_q1);
    QueueInit(&st->_q2);

    return st;
}

/** Push element x onto stack. */
void myStackPush(MyStack* obj, int x) {
    //非空队列入栈
    if(!QueueEmpty(&obj->_q1))
    {
        QueuePush(&obj->_q1, x);
    }
    else
    {
        QueuePush(&obj->_q2, x);
    }
}

/** Removes the element on top of the stack and returns that element. */
int myStackPop(MyStack* obj) {
    Queue* pemptyQ = &obj->_q1;
    Queue* pnoemptyQ = &obj->_q2;
    if(!QueueEmpty(&obj->_q1))
    {
        pemptyQ = &obj->_q2;
        pnoemptyQ = &obj->_q1;
    }

    while(QueueSize(pnoemptyQ) > 1)
    {
        QueuePush(pemptyQ, QueueFront(pnoemptyQ));
        QueuePop(pnoemptyQ);
    }
    int top = QueueBack(pnoemptyQ);
    QueuePop(pnoemptyQ);
    return top;
}

/** Get the top element. */
int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&obj->_q1))
    {
        return QueueBack(&obj->_q1);
    }
    else
    {
        return QueueBack(&obj->_q2);
    }
}

/** Returns whether the stack is empty. */
bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->_q1) && QueueEmpty(&obj->_q2);
}

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->_q1);
    QueueDestroy(&obj->_q2);
    free(obj);
    obj = NULL;
}

3、用栈实现队列
question3：请你仅使用两个栈实现先入先出队列。队列应当支持一般队列的支持的所有操作（push、pop、peek、empty）：
实现 MyQueue 类：
void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false
在这里插入图片描述

typedef int STDataType;

typedef struct Stack {
	STDataType* _a;
	int _top;// 栈顶
	int _capacity; // 容量
}Stack;

// 初始化栈 
void StackInit(Stack* ps)
{
	ps->_a = NULL;
	ps->_top = 0;
	ps->_capacity = 0;
}

//检查容量
void CheckCapacity(Stack* ps)
{
	if (ps->_top == ps->_capacity)
	{
		size_t newCapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		ps->_a = (STDataType*)realloc(ps->_a, newCapacity * sizeof(STDataType));
		if (!ps->_a)
			return;
			ps->_capacity = newCapacity;
	}
}

// 入栈
void StackPush(Stack* ps, STDataType data)
{
	CheckCapacity(ps);
	ps->_a[ps->_top++] = data;

}

// 出栈 
void StackPop(Stack* ps)
{
	assert(ps && ps->_top > 0);
	--ps->_top;
}

// 获取栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);
	return ps->_a[ps->_top - 1];
}

// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->_top == 0 ? 1 : 0;
}

// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = ps->_top = 0;
}

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

/** Initialize your data structure here. */

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

/** Push element x to the back of queue. */
void myQueuePush(MyQueue* obj, int x) {
    StackPush(&obj->pushst, x);
}

/** Removes the element from in front of queue and returns that element. */
int myQueuePop(MyQueue* obj) {
    if(StackEmpty(&obj->popst))
    {
        while(!StackEmpty(&obj->pushst))
        {
            StackPush(&obj->popst,StackTop(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }

    int front = StackTop(&obj->popst);
    StackPop(&obj->popst);

    return front;
}

/** Get the front element. */
int myQueuePeek(MyQueue* obj) {
    if(StackEmpty(&obj->popst))
    {
        while(!StackEmpty(&obj->pushst))
        {
            StackPush(&obj->popst,StackTop(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }

    return StackTop(&obj->popst);
}

/** Returns whether the queue is empty. */
bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->pushst) && StackEmpty(&obj->popst);
}

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

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

4、设计循环队列
question4：设计你的循环队列实现。循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

MyCircularQueue(k): 构造器，设置队列长度为 k
Front: 从队首获取元素。如果队列为空，返回 -1
Rear: 获取队尾元素。如果队列为空，返回 -1
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。

和顺序栈相似，在队列的顺序存储结构中，除了用一组地址连续的存储单元异地存放从队列到队尾的元素之外，尚需附设两个指针front和rear分别指示队列头元素及队列尾元素对的位置。我们默认，初始化空队列时，front = rear = 0，每当插入新的队尾元素时，“尾指针+1”；每当删除队列头元素时，“头指针+1”。因此，在非空队列中，头指针始终指向队列头元素，而尾指针始终指向队列尾元素的下一个位置。当队列满时。会有front = rear ，此时我们无法判断队列时空还是满，所以我们有两种解决方案1、可以少用一个元素空间，约定以“队列头指针在队列尾指针的下一位置”作为队列呈“满”状态的标志。2、另设一个标志位以区别队列是空还是满(capacity)

在这里插入图片描述




typedef struct {
    //队头元素的位置
    int _front;
    //队尾元素的下一个位置
    int _rear;
    //队列的容量
    int _k;
    //有效个数
    int _size;
    //存放元素空间的首地址
    int* _data;
} MyCircularQueue;

bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* cq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    cq->_data = (int*)malloc(sizeof(int) * k);
    cq->_k = k;
    cq->_front = cq->_rear = 0;
    cq->_size = 0;

    return cq;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    //队列已满，不能入队
    if(myCircularQueueIsFull(obj))
    {
        return false;
    } 
    //队尾入队
    obj->_data[obj->_rear++] = value;

    //判断队尾是否越界
    if(obj->_rear >= obj->_k)
      {
            obj->_rear = 0;
      }

    obj->_size++;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    //队列为空，出队失败
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    //队头出队
    obj->_front++;

    //判断队头是否越界
    if(obj->_front >= obj->_k)
    {
        obj->_front = 0;
    }

    obj->_size--;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {

     if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }

    return obj->_data[obj->_front];
}

int myCircularQueueRear(MyCircularQueue* obj) {

     if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }

    if(obj->_rear != 0)
    {
        return obj->_data[obj->_rear - 1];
    }
    else
    {
        return obj->_data[obj->_k - 1];
    } 
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {

    return obj->_size == 0;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {

    return obj->_size == obj->_k;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->_data);
    free(obj);
}

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/```