数据结构--栈，队列

includeevey 于 2022-08-08 08:45:00 发布
阅读量1.9k 收藏 88
点赞数 134
分类专栏： 数据结构 文章标签： 数据结构 c语言 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/includeevey/article/details/126212328
版权
数据结构 专栏收录该内容
5 篇文章 0 订阅
订阅专栏
本文详细介绍了栈和队列这两种基本数据结构，包括它们的概念、结构、实现方式以及在实际中的应用。栈遵循后进先出（LIFO）原则，常用于括号匹配等问题；队列遵循先进先出（FIFO）原则，常用于模拟队列行为。文章还展示了如何使用数组和链表实现栈和队列，并给出了相关面试题的解决方案，如用栈实现队列和用队列实现栈。此外，还提及了循环队列的概念及其在解决特定问题时的优势。
摘要由CSDN通过智能技术生成

前言

        这篇文章主要是关于栈与队列，为什么一般都是将栈与队列挨着讲，因为他们两个像一对欢喜冤家一样，在争锋相对的同时也互相成就，彼此通过不同的性质又可以联系在一起。本章节主要成分部分：什么是栈和队列，栈和队列的构造，栈和队列的习题。通过基础知识完成练习，通过练习巩固知识与理解栈与队列的联系。相信这篇文章会对大家有帮助，因为计算机就是解决我们生活中的问题，栈与队列的性质也是来源于生活中，比如栈--手枪的弹夹，队列--排队。

目录

前言

栈

栈的概念及结构

 栈的实现

实现代码

队列

队列的概念及结构

 队列的实现

 实现代码

循环队列

 栈和队列面试题

括号匹配问题---链接

用队列实现栈--链接

用栈实现队列--链接

设计循环队列--链接

栈

栈的概念及结构

栈：

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

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

动态演示

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

动态演示

 栈的实现

        栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为压栈与出栈正好满足数组的尾插与头删。数组的代价是及小的，操作相当于链表也更加简便。

动态演示

                                                                        压栈

出栈 

实现代码

主要步骤：

构建栈结构--数组，容量，栈顶

接口的实现--初始化栈 ，入栈，出栈 ，获取栈顶元素 ，获取栈中有效元素个数 ，检测栈是否为空， 销毁栈 

主函数演示

Stack.h

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

typedef int STDataType; 

//#define N 10
//typedef struct Stack
//{
//	   STDataType _a[N]; 
//	   int _top; // 栈顶
//}Stack;

// 支持动态增长的栈
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 
bool StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);

Stack.c

#define _CRT_SECURE_NO_WARNINGS
#include "Stack.h"

// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);//断言传入地址是否为空
	ps->_a = NULL;
	ps->_capacity = ps->_top = 0;
}

// 入栈
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		int newCapacity = ps->_capacity == 0 ? 4 : ps->_capacity*2;//判断容量是否为空并设置增加容量数量

		STDataType* temp = (STDataType*)realloc(ps->_a, newCapacity*sizeof(STDataType));//增加容量
		if (temp == NULL)//判断地址是否开辟成功
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->_a = temp;//赋址与结构体中
		ps->_capacity = newCapacity;//更新容量
	}
	ps->_a[ps->_top] = data;//数据入栈
	ps->_top++;//栈顶++
}

// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));//断言栈是否为空
	--ps->_top;//栈顶--
}

// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->_a[ps->_top-1];
}

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

	return ps->_top;
}

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

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

Test.c

#define _CRT_SECURE_NO_WARNINGS
#include "Stack.h"


//进栈--出栈演示
void TestStack()
{
	Stack ps;
	StackInit(&ps);
	StackPush(&ps,5);
	StackPush(&ps,6);
	StackPush(&ps,7);
//	printf("%d ", StackTop(&ps));
	StackPop(&ps);
//	printf("%d ", StackTop(&ps));
	StackPop(&ps);

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

int main()
{
	TestStack();

	return 0;
}

队列

队列的概念及结构

队列：

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

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

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

动态演示

 队列的实现

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

动态演示

 实现代码

实现步骤：

构建链式结构--结构体指针，数据

构建队列结构--头指针，尾指针

接口的实现--初始化队列 ，队尾入队列 ，队头出队列 ，获取队列头部元素，获取队列队尾元素 ，获取队列中有效元素个数 ， 检测队列是否为空 ， 销毁队列 。

主函数演示

Queue.h

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

// 链式结构：表示队列 
typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
	QDataType _size;
}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 
bool QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);

Queue.c

#include "Queue.h"

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

// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);

	QNode* cur = (QNode*)malloc(sizeof(QNode));
	if (cur == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	else
	{
		cur->_data = data;
		cur->_next = NULL;
	}

	if (q->_rear == NULL)
	{
		q->_front = q->_rear = cur;
	}
	else
	{
		q->_rear->_next = cur;
		q->_rear = cur;
	}
	q->_size++;
}

// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	if (q->_front->_next==NULL)
	{
		free(q->_front);
		q->_front = q->_rear = NULL;
	}
	else
	{
		QNode* cur = q->_front;
		q->_front = q->_front->_next;
		free(cur);
		cur = NULL;
	}
	q->_size--;
}
// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->_front->_data;
}

// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->_rear->_data;
}

// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	
	return q->_size;
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
bool QueueEmpty(Queue* q)
{
	assert(q);

	return q->_front == NULL && q->_rear == NULL;
}

// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->_front;
	while (cur)
	{
		QNode* del = cur;
		cur = cur->_next;
		free(del);
		del = NULL;
	}
	q->_front = q->_rear = NULL;
}

Test.c

#define _CRT_SECURE_NO_WARNINGS
#include "Queue.h"

void TestQueue()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePop(&q);
	printf("%d ", QueueFront(&q));
//	printf("%d ", QueueBack(&q));
	QueuePush(&q, 7);
	printf("%d ", QueueBack(&q));
	QueuePush(&q, 8);
	printf("%d ", QueueBack(&q));
	QueuePush(&q, 9);
	QueuePush(&q, 10); 
	QueuePush(&q, 11);

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

	QueueDestroy(&q);
}

int main()
{
	TestQueue();

	return 0;
}

循环队列

        另外扩展了解一下，实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型 时可以就会使用循环队列。环形队列可以使用数组实现，也可以使用循环链表实现。

 

 栈和队列面试题

括号匹配问题--- 链接

动态演示

 

 两种特殊错误情况

实现代码

typedef char 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 
bool StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);

// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);//断言传入地址是否为空
	ps->_a = NULL;
	ps->_capacity = ps->_top = 0;
}

// 入栈
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		int newCapacity = ps->_capacity == 0 ? 4 : ps->_capacity*2;//判断容量是否为空并设置增加容量数量

		STDataType* temp = (STDataType*)realloc(ps->_a, newCapacity*sizeof(STDataType));//增加容量
		if (temp == NULL)//判断地址是否开辟成功
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->_a = temp;//赋址与结构体中
		ps->_capacity = newCapacity;//更新容量
	}
	ps->_a[ps->_top] = data;//数据入栈
	ps->_top++;//栈顶++
}

// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));//断言栈是否为空
	--ps->_top;//栈顶--
}

// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->_a[ps->_top-1];
}

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

	return ps->_top;
}

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

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

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;
            }
            char tem= StackTop(&st);
            StackPop(&st);
            if(*s=='}' && tem!='{' || *s==')' && tem!='(' || *s==']' && tem!='[')
            {
                StackDestroy(&st);
                return false;
            }
        }
        s++;
    }
    bool flag=StackEmpty(&st);
    StackDestroy(&st);
    return flag;
}

用队列实现栈-- 链接

动态演示

 

 实现代码

// 链式结构：表示队列 
typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
	QDataType _size;
}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 
bool QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);


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

// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);

	QNode* cur = (QNode*)malloc(sizeof(QNode));
	if (cur == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	else
	{
		cur->_data = data;
		cur->_next = NULL;
	}

	if (q->_rear == NULL)
	{
		q->_front = q->_rear = cur;
	}
	else
	{
		q->_rear->_next = cur;
		q->_rear = cur;
	}
	q->_size++;
}

// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	if (q->_front->_next==NULL)
	{
		free(q->_front);
		q->_front = q->_rear = NULL;
	}
	else
	{
		QNode* cur = q->_front;
		q->_front = q->_front->_next;
		free(cur);
		cur = NULL;
	}
	q->_size--;
}
// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->_front->_data;
}

// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->_rear->_data;
}

// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	
	return q->_size;
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
bool QueueEmpty(Queue* q)
{
	assert(q);

	return q->_front == NULL && q->_rear == NULL;
}

// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->_front;
	while (cur)
	{
		QNode* del = cur;
		cur = cur->_next;
		free(del);
		del = NULL;
	}
	q->_front = q->_rear = NULL;
}

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);
    }
}

//出栈 QueuePop
int myStackPop(MyStack* obj) {
    QNode* empty=&obj->q1;
    QNode* nonempty=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        empty=&obj->q2;
        nonempty=&obj->q1;
    }
    
    while(QueueSize(nonempty)>1)
    {
         QueuePush(empty,QueueFront(nonempty));
         QueuePop(nonempty);
    }
    int top=QueueFront(nonempty);
    QueuePop(nonempty);
    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);
    obj==NULL;
}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/

用栈实现队列-- 链接

动态演示

  实现代码

typedef int STDataType; 

//#define N 10
//typedef struct Stack
//{
//	   STDataType _a[N]; 
//	   int _top; // 栈顶
//}Stack;

// 支持动态增长的栈
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 
bool StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);

// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);//断言传入地址是否为空
	ps->_a = NULL;
	ps->_capacity = ps->_top = 0;
}

// 入栈
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		int newCapacity = ps->_capacity == 0 ? 4 : ps->_capacity*2;//判断容量是否为空并设置增加容量数量

		STDataType* temp = (STDataType*)realloc(ps->_a, newCapacity*sizeof(STDataType));//增加容量
		if (temp == NULL)//判断地址是否开辟成功
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->_a = temp;//赋址与结构体中
		ps->_capacity = newCapacity;//更新容量
	}
	ps->_a[ps->_top] = data;//数据入栈
	ps->_top++;//栈顶++
}

// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));//断言栈是否为空
	--ps->_top;//栈顶--
}

// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->_a[ps->_top-1];
}

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

	return ps->_top;
}

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

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

typedef struct {
    Stack push;
    Stack pop;

} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj=(MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&obj->push);
    StackInit(&obj->pop);

    return obj;
}

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

int myQueuePop(MyQueue* obj) {
   if(StackEmpty(&obj->pop))
   {
       while(!StackEmpty(&obj->push))
     {
       StackPush(&obj->pop,StackTop(&obj->push));
       StackPop(&obj->push);
     }
   }
   
   STDataType tem =StackTop(&obj->pop);
   StackPop(&obj->pop);
   
   return tem;
}

int myQueuePeek(MyQueue* obj) {
    if(StackEmpty(&obj->pop))
   {
       while(!StackEmpty(&obj->push))
     {
       StackPush(&obj->pop,StackTop(&obj->push));
       StackPop(&obj->push);
     }
   }
    
    return StackTop(&obj->pop);
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->push)&&StackEmpty(&obj->pop);
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->push);
    StackDestroy(&obj->pop);
    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);
*/

设计循环队列-- 链接

用数组更好还是链表

在考虑用谁更好时，有个问题已经来了，如何判断满和空

判断空只需要front==rear就为空

 判断满 有两个方法： 1.用size计数 2.增加一个空节点

这里如果用size的话我们发现实现循环还是需要加节点，那如果不加呢？

不加节点我们发现，先走的rear，如果满了rear与front就重复了到底是空还是满就不好判断。所以这里我们选择加节点。

当加了节点我们发现循环之后需要获取队列最后一个元素时，需要重新遍历或者加一个指向前面的指针

当我们决定用数组时我们需要注意什么呢？

 当rear进行循环时，rear+1会出现越界的问题，如何解决呢？

我们只需要（rear+1）%rear 即可，就可以进行循环。

动态演示

 实现代码

typedef struct {
    int *a;
    int front;
    int rear;
    int N;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a=(int*)malloc((k+1)*sizeof(int));
    obj->front=obj->rear=0;
    obj->N=k+1;
    
    return obj;
}

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

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

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if( myCircularQueueIsFull(obj))
    return false;

    obj->a[obj->rear]=value;
    obj->rear++;
    obj->rear %= obj->N;

    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    return false;

    obj->front++;

    obj->front %= obj->N;
    return true;
}

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

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return -1;
    else
        return obj->a[(obj->rear+obj->N-1)%obj->N];
}



void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    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);
*/

stack容器
一路向北
03-20 1197
Stack简介 stack是堆栈容器，是一种“先进后出”的容器。 stack是简单地装饰deque容器而成为另外的一种容器。 #include <stack> stack对象的默认构造 stack采用模板类实现， stack对象的默认构造形式： stack <T> stkT; stack <int> stkInt; //一个存...
数据结构---栈和队列之顺序栈（C语言）
05-05
在这个主题中，我们将专注于两种基本的线性数据结构：栈和队列，特别是C语言实现的顺序栈。顺序栈是一种在内存中连续分配空间的抽象数据类型，它具有后进先出（LIFO）或先进后出（FILO）的特性。 ### 栈的基本概念 ...
C++之stack.top()
lost607的专栏
05-07 7893
写一个括号匹配函数，用栈实现，思路jian
STL详解（二） 栈容器Stack
流年的博客
02-11 4279
一、Stack简介 stack 是容器适配器的一种。要使用 stack，必须包含头文件 <stack>。 stack就是“栈”。栈是一种后进先出的元素序列，访问和删除都只能对栈顶的元素（即最后一个被加入栈的元素）进行，并且元素也只能被添加到栈顶。栈内的元素不能访问。如果一定要访问栈内的元素，只能将其上方的元素全部从栈中删除，使之变成栈顶元素才可以。 容器适配器中的数据是以 LIF...
栈：关于某次使用stack.top()程序运行不出来的问题
Alanrookie的博客
06-29 1380
显然我们使用stack.top()的前提条件是!stack.empty()(地球人都知道)，问题在于编译器编译的时候是一个判断条件一个判断条件编译的（不是官方语言，我只说自己的理解），如果！s.empty()和s.top()写在一个条件语句中，s.empty()必须写在s.top()的前面，否者在空状态下直接读取s.top()语句，编译器会陷入死循环出不来。 #include <iostream> #include <cstring> #include <cstdio&gt
栈文档之顺序栈
二木成林
04-22 4376
采用顺序存储的栈称为顺序栈，它采用一组地址连续的存储单元存放自栈底到栈顶的数据元素，同时设定一个指针（top）指向当前栈顶元素的位置。通常采用数组来实现。
数据结构---栈和队列之共享栈（C语言）
05-05
数据结构---栈和队列之共享栈（C语言）完整代码，可以运行
数据结构学习-队列/栈
最新发布
04-28
### 数据结构学习——队列与栈 #### 一、队列的基本概念 队列是一种特殊的线性表，只允许在表的一端进行插入操作，在另一端进行删除操作。这种操作方式使得队列遵循先进先出（FIFO, First In First Out）的原则。...
数据结构---栈和队列之链栈（C语言）
05-05
栈是一种后进先出（LIFO, Last In First Out）的数据结构，而队列则是先进先出（FIFO, First In First Out）的数据结构。链栈是栈的一种实现方式，它通过链式存储结构来实现栈的功能。 ### 栈的概念与操作 栈是一种...
数据结构---栈和队列之顺序队（C语言）
05-05
本主题聚焦于两种基本数据结构：栈和队列，特别是它们的一个实例——顺序队，用C语言实现。这里我们将深入探讨这些概念以及它们在实际编程中的应用。 栈是一种后进先出（LIFO）的数据结构，这意味着最后插入的元素...
重学数据结构之第四章-栈与队列
James-Tom的博客
10-03 415
1、栈的定义 2、栈的两种存储结构 2.1、顺序存储结构 2.1.1、进栈 2.1.2、出栈 2.2、链式存储结构 2.1.1、进栈 2.1.2、出栈 3、栈的应用-斐波那契的递归函数 3.1、迭代法 3.2、递归法 3.3、对比两种实现方法 4、队列的定义 4、队列的两种存储结构 2.1、顺序存储结构 2.1.1、出队 2.1.2、入队 2.2、链式存储结构 2.1.1、出队 2.1.2、入队 5、总结 栈和队列它们都是特殊的线性表，只不过对插入和删除操作做了限制。 栈（stack）是限定仅在表尾进行插入
【数据结构】 详解栈
weixin_61932507的博客
03-27 1285
【数据结构】详解栈
python实现栈，实现push(),pop(),top(),getMin()方法
菜鸡小白的成长记录
06-25 1万+
设计一个栈，该栈可以进行push、pop、top和在常数时间内检索最小值的操作 push(x) – 压一个数到栈顶 pop() – 移除栈顶的元素，不返回任何对象 top() – 返回栈顶端的元素 getMin() – 检索栈中的最小值 方法1：引入minStack列表存放最小值，原生态的min()函数比较花费时间。 class MinStack(object): def __init...
栈（stack）的用处
AnZQ-ZY
11-21 1373
栈 目录 栈的一个实际需求 栈的介绍 栈的应用场景 栈的一个实际需求 栈的介绍 栈是一个先入后出的有队列 栈是限制线性表中的元素的插入和删除只能在同一端的一种特殊的线性表，允许插入和删除的一端成为栈顶（Top），固定的一段称为栈底（Bottom） 根据定义可知，最先放入的元素在栈底，而最后放入的元素在栈顶。最先放入的后删除，后放入的先删除。 图解如下： 栈的应用场景 子程序的调用：在跳往子程序前，会先将下个指令的地址存在堆栈中，直到子程序执行完成后在将地址取出，以回到原来的程序
std::stack 基本操作
热门推荐
天才樱木
09-10 2万+
C++ Stack（堆栈） 是一个容器类的改编，为程序员提供了堆栈的全部功能，——也就是说实现了一个先进后出（FILO）的数据结构。 c++ stl栈stack的头文件为:  #include &lt;stack&gt;  c++ stl栈stack的成员函数介绍 操作 比较和分配堆栈 empty() 堆栈为空则返回真 pop() 移除栈顶元素 push() 在栈顶增加元素 siz...
数据结构与算法3：操作受限的线性表——栈
爱丹丹的博客
10-12 1068
文章目录栈(stack)的定义栈的抽象数据类型栈的顺序存储栈的链式存储栈的应用 栈(stack)的定义 例子 弹夹式手枪压入子弹 浏览器前进后退键 文档图像软件中的撤销操作 定义 定义:栈(stack)是限定只在表尾进行插入和删除操作的线性表 允许插入和删除的一端称为栈顶(top),另一端称为栈底(bottom),不含任何数据元素的栈称为空栈. 栈又称为后进先出(Last In Firs...
栈的概念及其实现
qq_41936794的博客
04-27 244
1 前言 栈是一种特殊的线性表,栈仅能在线性表的一端进行操作,栈顶(Top)为允许操作的一端,栈底(Bottom)为不允许操作的一端,栈的特性就是后进先出(Last In First Out),只允许在线性表的一段进行操作 栈可以看成一个容器,所以栈的操作有创建栈,销毁栈,清空栈,进栈(pop),出栈(push),获取栈顶元素,获取栈的大小,对于栈有静态栈和动态栈,所以我们可以抽象出一个**栈父...
数据结构(Link,Queue,Stack,hash表)
tianhumanong的博客
04-17 1752
1.基本的三种数据结构类型 1、线性表 结点按逻辑关系依次排列形成一个“锁链” 2、树 ​ 具有分支、层次特性,其形态有点象自然界中的树 3、图 ​ 结点按逻辑关系互相缠绕,任何两个结点都可以邻接 2.数组就是一种典型的线性表 1、数组其实就是一种典型的线性表，而且是一种物理连续的线性表 2、数组的特点： 通过下标（内存偏移量，单位是元素个数）进行元素访问 数组中每个元素的类型必须一致 数组的大小一旦确定就不能变更 3.链表 1、链表是一种逻辑上连续的线性表，所谓
c++之stack栈模型
Xiao_qsn的博客
03-31 393
c++之stack栈模型 文章目录c++之stack栈模型前言一、stack使用方法二、用法案例 前言 #include stack是堆栈容器，是一种“先进后出的容器” 一、stack使用方法 stack.push(elem); //往栈头添加元素 stack.pop(); //从栈头移除以第一个元素 stack.top(); //返回最后一个入栈元素 stack.empty();//判断栈是否为空 stack.size();//返回堆栈大小 二、用法案例
写文章

热门文章

  • c++介绍与入门基础（详细总结） 9778
  • c++类和对象 7693
  • VS Code的使用 5525
  • C++之多态【详细总结】 5202
  • Linux--权限 5133

分类专栏

  • c++ 13篇
  • Linux 10篇
  • 数据结构 5篇
  • c语言 24篇

最新评论

  • C++11

    m0_63986570: 求更表情包表情包表情包

  • 【c++】STL--string

    微软技术分享: 高质量文章，感谢博主分享，支持博主创作！

  • C++11

    王平渊: 佬的文章还是一如既往的干货满满，支持佬

  • C++11

    迷茫的启明星: 哇，C++11学到了学到了

  • C++11

    bluetata: C++也在不对进步更新，毕竟时代还是要向前的，文章写的很好，学习了

最新文章

  • C++11
  • Linux--进程多线程（上）
  • Linux--进程信号
2023年14篇
2022年41篇

目录

目录

评论 135
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

includeevey

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或 充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值

玻璃钢生产厂家金昌公园玻璃钢雕塑安装湛江市哪里有卖玻璃钢花盆的玻璃钢花盆模具批发价格大旺玻璃钢动物雕塑批发重庆公园玻璃钢雕塑供应商湖北环保玻璃钢雕塑定制衢州户内玻璃钢雕塑销售厂家特色玻璃钢雕塑摆件销售公司昆山玻璃钢雕塑厂招聘陕西玻璃钢卡通雕塑生产珠海商场玻璃钢卡通雕塑欧式玻璃钢卡通雕塑销售价格惠安玻璃钢仿真雕塑山东佛像玻璃钢雕塑多少钱城建绿化玻璃钢花盆厂家许昌肖像玻璃钢雕塑重庆玻璃钢门头雕塑宿迁玻璃钢仿铜雕塑山东大型商场创意商业美陈怎么样绍兴玻璃钢卡通雕塑圣诞菏泽室外校园玻璃钢雕塑厂家玻璃钢抽象海鸥雕塑长沙哪里有玻璃钢卡通雕塑舟山抽象玻璃钢雕塑哪家便宜河南常用商场美陈有哪些绵阳成都商场美陈排行玻璃钢花盆雕塑定制玻璃钢雕塑的过程河北玻璃钢雕塑厂家电话玻璃钢型材雕塑香港通过《维护国家安全条例》两大学生合买彩票中奖一人不认账让美丽中国“从细节出发”19岁小伙救下5人后溺亡 多方发声单亲妈妈陷入热恋 14岁儿子报警汪小菲曝离婚始末遭遇山火的松茸之乡雅江山火三名扑火人员牺牲系谣言何赛飞追着代拍打萧美琴窜访捷克 外交部回应卫健委通报少年有偿捐血浆16次猝死手机成瘾是影响睡眠质量重要因素高校汽车撞人致3死16伤 司机系学生315晚会后胖东来又人满为患了小米汽车超级工厂正式揭幕中国拥有亿元资产的家庭达13.3万户周杰伦一审败诉网易男孩8年未见母亲被告知被遗忘许家印被限制高消费饲养员用铁锨驱打大熊猫被辞退男子被猫抓伤后确诊“猫抓病”特朗普无法缴纳4.54亿美元罚金倪萍分享减重40斤方法联合利华开始重组张家界的山上“长”满了韩国人？张立群任西安交通大学校长杨倩无缘巴黎奥运“重生之我在北大当嫡校长”黑马情侣提车了专访95后高颜值猪保姆考生莫言也上北大硕士复试名单了网友洛杉矶偶遇贾玲专家建议不必谈骨泥色变沉迷短剧的人就像掉进了杀猪盘奥巴马现身唐宁街 黑色着装引猜测七年后宇文玥被薅头发捞上岸事业单位女子向同事水杯投不明物质凯特王妃现身！外出购物视频曝光河南驻马店通报西平中学跳楼事件王树国卸任西安交大校长 师生送别恒大被罚41.75亿到底怎么缴男子被流浪猫绊倒 投喂者赔24万房客欠租失踪 房东直发愁西双版纳热带植物园回应蜉蝣大爆发钱人豪晒法院裁定实锤抄袭外国人感慨凌晨的中国很安全胖东来员工每周单休无小长假白宫：哈马斯三号人物被杀测试车高速逃费 小米：已补缴老人退休金被冒领16年 金额超20万

玻璃钢生产厂家 XML地图 TXT地图 虚拟主机 SEO 网站制作 网站优化