拿捏《数据结构》线性表之栈和队列

最新推荐文章于 2024-05-17 23:32:03 发布
最新推荐文章于 2024-05-17 23:32:03 发布
阅读量161 收藏 3
点赞数 6
分类专栏： 数据结构专栏 文章标签： 数据结构 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LibraRhy/article/details/126061980
版权

目录

1.栈的表示和实现

1.1栈的概念及结构

1.2栈的实现

1.3栈的代码

2.队列的表示和实现

2.1队列的概念及结构

2.2队列的实现

 2.3队列代码

3.终极队列和栈的OJ题

3.1 括号匹配问题。

3.2 用队列实现栈。

3.3 用栈实现队列

1.栈的表示和实现

1.1栈的概念及结构

个人理解：栈就相当于手枪的子弹夹，塞子弹的弹夹口就是栈顶，弹夹另一端就是栈底。先塞进去的子弹最后打出去，最后塞进弹夹的子弹第一个打

出去。正所谓后来者居上！！!LIFO（Last In First Out）

官方定义：

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。 进行数据插入和删除

操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）

的原则。
压栈：栈的插入操作叫做进栈 / 压栈 / 入栈， 入数据在栈顶 。
出栈：栈的删除操作叫做出栈。 出数据也在栈顶 。

 

1.2栈的实现

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

1.3栈的代码

 使用动态数组实现可动态增长的栈：

//动态数组实现栈的各种接口

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

//初始化栈
void StackInit(Stack* ps);
//栈的销毁
void StackDestory(Stack* ps);
//内存检查，不够则自动扩容
void CheckCapacity(Stack*ps);
//进栈
void StackPush(Stack* ps, SDataType x);
//出栈
void StackPop(Stack* ps);
//判空
bool StackEmpty(Stack*ps);
//获取栈顶元素
SDataType StackTop(Stack*ps);
//计算栈中元素个数
SDataType StackSize(Stack*ps);
老规矩以下分别实现各个接口函数： 
void StackInit(Stack*ps)
{
	ps->a = 0;
	ps->capacity = 0;
	ps-> top = 0;

}
void CheckCapacity(Stack*ps)
{
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SDataType*tmp = (SDataType*)realloc(ps->a,sizeof(SDataType)*newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
	}
	
}

void StackDestory(Stack*ps)
{
	assert(ps);
	free(ps->a);
	ps->capacity = ps->top = 0;
	ps->a= NULL;
	
}
void StackPush(Stack* ps,SDataType x)
{
	assert(ps);
	CheckCapacity(ps);
	ps->a[ps->top] = x;
	ps->top++;
}
void StackPop(Stack* ps)
{

	assert(ps);
	assert(ps->top > 0);
	ps->top--;

}
bool StackEmpty(Stack*ps)
{
	assert(ps);
	return ps->top==0;
}
SDataType StackTop(Stack*ps)
{
	assert(ps);
	assert(ps -> top > 0);
	return ps->a[ps->top-1];
}
SDataType StackSize(Stack*ps)
{
	assert(ps);
	return ps->top;
}

       

2.队列的表示和实现

2.1队列的概念及结构

个人理解：字面意思，队列就是我们日常生活中排队的队列，谁先排入队列中的先轮到谁。

FIFO(First In First Out) 严格按照这一规律，不能插队！不同的是还不能在排队中途退出排队！hh 是不是很坑！

官方定义：

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

2.2队列的实现

 队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，

出队列在数组头上出数据，效率会比较低。
此处采用无头不循环单链表实现

 2.3队列代码

//单链表实现队列
//链式结构表示队列
typedef int SDataType;
typedef struct QueueNode   
{
	SDataType data;
	struct QueueNode* next;
}QNode;

//队列的结构
typedef struct Queue
{
	QNode* head;   //指向队头的指针
	QNode* tail;    //指向队尾的指针
}Queue;
//队列的初始化
void QueueInit(Queue*pq);
//销毁
void QueueDestroy(Queue*pq)
//队尾入
void QueuePush(Queue*pq,SDataType x); 
//队头出
void QueuePop(Queue*pq);    
//获取队头元素
SDataType QueueFront(Queue*pq);
//获取队尾元素
SDataType QueueBack(Queue*pq);
//判空
bool QueueEmpty(Queue*pq);
//元素个数
int QueueSize(Queue*pq);

老规矩 以下分别实现上述各个接口函数：

void QueueInit(Queue*pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}
void QueueDestroy(Queue*pq)
{
	assert(pq);
	QNode *val = pq->head;
	while (pq->head != NULL)
	{
		pq->head=pq->head->next;
		free(val);
	}
	
}
void QueuePush(Queue*pq,SDataType x)//队尾入
{
	assert(pq);
	QNode*newnode = (QNode*)malloc(sizeof(QNode));
	newnode->data = x;
	newnode->next = NULL;
	if (pq->tail == NULL)	
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = pq->tail->next;
	}
}
void QueuePop(Queue*pq)   //队头出
{
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode*next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}

}
SDataType QueueFront(Queue*pq)
{
	assert(pq);
	assert(pq->head);
	return pq->head->data;
}
SDataType QueueBack(Queue*pq)
{
	assert(pq);
	assert(pq->head);
	return pq->tail->data;
}
bool QueueEmpty(Queue*pq)
{
	assert(pq);
	return pq->head == NULL;
}
int QueueSize(Queue*pq)
{
	QNode*cur = pq->head;
	int size = 0;
	while (cur != 0)
	{
		cur = cur->next;
		size++;
	}
	return size;
}

3.终极队列和栈的OJ题

3.1 括号匹配问题。

解答如下： 
typedef char SDataType;
typedef struct Stack
{
	SDataType *a;
	int capacity;
	int top;
}Stack;


void StackInit(Stack*ps)
{
	ps->a = 0;
	ps->capacity = 0;
	ps-> top = 0;

}
void CheckCapacity(Stack*ps)
{
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SDataType*tmp = (SDataType*)realloc(ps->a,sizeof(SDataType)*newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
	}
	
}

void StackDestory(Stack*ps)
{
	assert(ps);
	free(ps->a);
	ps->capacity = ps->top = 0;
	ps->a= NULL;
	
}
void StackPush(Stack* ps,SDataType x)
{
	assert(ps);
	CheckCapacity(ps);
	ps->a[ps->top] = x;
	ps->top++;
}
void StackPop(Stack* ps)
{

	assert(ps);
	assert(ps->top > 0);
	ps->top--;
	
}
bool StackEmpty(Stack*ps)
{
	assert(ps);
	return ps->top==0;
}
SDataType StackTop(Stack*ps)
{
	assert(ps);
	assert(ps -> top > 0);
	return ps->a[ps->top-1];
}
SDataType StackSize(Stack*ps)
{
	assert(ps);
	return ps->top;
}
bool isValid(char * s)
{
    Stack st;
    StackInit(&st);
    while(*s!='\0')
    {
        switch(*s)
        {
        case'{':
        case'(':
        case'[':
        {
            StackPush(&st,*s);
            *s++;
            break;
        }
        case '}':
        case ')':
        case ']':
        {
            if(StackEmpty(&st))
            {
                StackDestory(&st);
                return false;
            }
            char top=StackTop(&st);
            StackPop(&st);
            if((top=='{' && *s !='}')
            ||(top=='(' && *s !=')')
            ||(top=='[' && *s !=']'))
            {
                 StackDestory(&st);
                return false;
            }
           
            else
            {
                *s++;
                
            }
            break;
        }
        }
    }
    bool ret=StackEmpty(&st);
    return ret;
    StackDestory(&st);
}

3.2 用队列实现栈。

typedef int QDataType;
typedef struct QueueNode   //单链表实现队列
{
	QDataType data;
	struct QueueNode* next;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
}Queue;
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}

void QueueDestory(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

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

// 队尾入
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}

	newnode->data = x;
	newnode->next = NULL;

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

// 队头出
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head);

	// 1、一个
	// 2、多个
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
}


QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);

	return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->head);

	return pq->tail->data;
}

int QueueSize(Queue* pq)
{
	assert(pq);
	int size = 0;
	QNode* cur = pq->head;
	while (cur)
	{
		++size;
		cur = cur->next;
	}

	return size;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head==NULL ;    //条件成立 返回true   不成立返回false
}

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


MyStack* myStackCreate() 
{
    MyStack*ps=(MyStack*)malloc(sizeof(MyStack));
    if(ps==NULL)
    {
        exit(-1);
    }
    QueueInit(&ps->q1);
    QueueInit(&ps->q2);
    return ps;
}

void myStackPush(MyStack* obj, int x) 
{
    if(!QueueEmpty(&obj->q1))
    {
         QueuePush(&obj->q1,x);
    }
     
   else
    {
        QueuePush(&obj->q2,x);
    }
       
}

int myStackPop(MyStack* obj) 
{
    Queue*emptyQ=&obj->q1;
    Queue*noemptyQ=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        emptyQ=&obj->q2;
        noemptyQ=&obj->q1;
    }
        
    while(QueueSize(noemptyQ)>1)
    {
        QueuePush(emptyQ,QueueFront(noemptyQ));
        QueuePop(noemptyQ);
    }
    int top= QueueFront(noemptyQ);
    QueuePop(noemptyQ);
    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) 
{
    QueueDestory(&obj->q1);
     QueueDestory(&obj->q2);
     free(obj);
}

3.3 用栈实现队列

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

void StackInit(Stack*ps)
{
	ps->a = 0;
	ps->capacity = 0;
	ps-> top = 0;

}
void CheckCapacity(Stack*ps)
{
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SDataType*tmp = (SDataType*)realloc(ps->a,sizeof(SDataType)*newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
	}
	
}

void StackDestory(Stack*ps)
{
	assert(ps);
	free(ps->a);
	ps->capacity = ps->top = 0;
	ps->a= NULL;
	
}
void StackPush(Stack* ps,SDataType x)
{
	assert(ps);
	CheckCapacity(ps);
	ps->a[ps->top] = x;
	ps->top++;
}
void StackPop(Stack* ps)
{

	assert(ps);
	assert(ps->top > 0);
	ps->top--;
	
}
bool StackEmpty(Stack*ps)
{
	assert(ps);
	return ps->top==0;
}
SDataType StackTop(Stack*ps)
{
	assert(ps);
	assert(ps -> top > 0);
	return ps->a[ps->top-1];
}
SDataType StackSize(Stack*ps)
{
	assert(ps);
	return ps->top;
}

typedef struct 
{
    Stack s1;
    Stack s2;
} MyQueue;


MyQueue* myQueueCreate() 
{
    MyQueue*ps=(MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&ps->s1);
     StackInit(&ps->s2);
     return ps;
}

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

int myQueuePop(MyQueue* obj) 
{
    
    if(StackEmpty(&obj->s2))
    {
       while(!StackEmpty(&obj->s1))
        {
            StackPush(&obj->s2,StackTop(&obj->s1));
            StackPop(&obj->s1);
        }
    }
   
   
    int top=StackTop(&obj->s2);
    StackPop(&obj->s2);
    return top;
   // int top = myQueuePeek(obj);
	//StackPop(&obj->s2);
	//return top;
}

int myQueuePeek(MyQueue* obj) 
{
    if(StackSize(&obj->s2)==0)
    {
       while(StackSize(&obj->s1)>0)
       {
           StackPush(&obj->s2,StackTop(&obj->s1));
            StackPop(&obj->s1);
       }
    }
    return StackTop(&obj->s2);
        
}

bool myQueueEmpty(MyQueue* obj) 
{
    
    return StackEmpty(&obj->s1) && StackEmpty(&obj->s2);
}

void myQueueFree(MyQueue* obj) 
{
    StackDestory(&obj->s1);
    StackDestory(&obj->s2);
    free(obj);
}

后面两题类似都是使用队列和栈的性质 来回操作。

爱算法的喵酱
关注
  • 6
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
数据结构：线性表、链表、队列、栈、串
11-24
包含数据结构中线性表、链表、队列、栈、串等几种结构的常见操作，以及顺序和链式存储过程
数据结构实验（线性表、栈、队列）
11-20
A，使其左边的所有元素小于 0，右边的所有元素大于 0（要求算法的时间复杂度和空 间复杂度均为 O(n)）。 （2）建立一个循环单链表，其节点有 prior，data 和 next 三个域，其中 data 为数 据域，存放元素的有效信息...
【数据结构】线性表之“栈”和“队列”
xboll2020的博客
12-07 242
我：怎样拿捏栈和队列？ 栈：6 队列：6
数据结构——算法竞赛中熠熠生辉的两朵金花—“栈“和“队列“
weixin_52621323的博客
12-15 1452
一篇长文，亿点图片，详细演示，带你逐渐把栈和队列在程序设计大赛中的玩法弄明白呀~
＜ 数据结构 ＞ w字拿捏链式二叉树
bit_zyx的博客
04-22 1420
1、为何使用链式二叉树 2、何为链式二叉树 3、基本接口 创建二叉链结构 手动构建一颗树 4、二叉树的遍历 前序遍历 中序遍历 后续遍历 层序遍历 5、经典问题 结点个数 叶结点个数 第K层结点个数 二叉树的深度 二叉树查找值为x的节点 二叉树的销毁 判断二叉树是否是完
史上最强数据结构----轻松拿捏队列及队列的模拟实现
m0_57304511的博客
04-06 1750
史上最强数据结构----轻松拿捏队列及队列的模拟实现
[ 数据结构-C实现 ] 栈 Stack
CSDN博客
03-25 2802
目录 1.栈 1.1栈的概念和结构 2.栈的实现 2.1接口 2.2接口的实现 2.2.1初始化 2.2.2销毁 2.2.3入栈--进栈--压栈 2.2.4出栈 2.2.5判断栈是否为空 2.2.6栈的大小 2.2.7栈顶 完整代码： 1.栈 1.1栈的概念和结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端 称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
[数据结构1.0]队列
X__cheng的博客
03-07 1445
QNode;int k;}Queue;老样子我们将int重命名成QDatatype，方便以后代码的维护。让后定义并重命名结构体QNode充当队列节点 ，这些节点根据数据元素的入队列或者出队列按需申请或者释放。QNode中成员_data用来存放数据元素，QNode中成员_next用来链接下一个节点。
速学数据结构 | 用队列实现栈你都被难住了？那是你没掌握好技巧
鸽芷咕的博客
11-05 5218
栈和队列都是线性表中比较特殊的一种，这俩种我们都学了那么用队列实现栈不知道把你难倒了嘛！看完保证你对队列的理解又上一个档次!
【数据结构】带你轻松拿捏顺序表（内附源码）
君兮_的博客
07-27 677
0基础入门数据结构顺序表，就算是小白也能轻松看懂！！！
线性表-定义和顺序存储结构
朝花夕拾
02-26 2782
3.1 开场白 各位同学，大家好。 今天我们要开始学习数据结构中最常用和最简单的一种结构，在介绍它之前先讲个例子。 我经常下午去幼儿园接送儿子，每次都能在门口看到老师带着小朋友们， 一个拉着另一个的衣服，依次从教室出来 。而且我发现很有规律的是，每次他们的次序都是一样。比如我儿子排在第 5 个，每次他都是在第 5 个，前面同样是那个小女孩，后面一直是那个小男孩。这点让我很奇怪，为
数据结构实验报告 线性表 串 队列 栈.doc
04-01
大学数据结构课实验报告
数据结构与算法实验，线性表，栈和队列，二叉树，图结构
01-18
数据结构与算法实验，线性表，栈和队列，二叉树，图结构
数据结构线性表、栈队列的思维导图.zip
08-09
只有线性表、栈队列的
数据结构 | 详解栈实现队列&队列实现栈
最新发布
mooridy的博客
05-17 326
step2：此时非空队列中剩下的唯一一个数就是“栈顶”元素，使用QueueFront进行·取值后，直接进行QueuePop删除。step0.先利用假设法假定非空队列notempty和空队列empty，再利用MyStackEmpty函数对进行修正。step1:将notempty队列中的前size-1个元素依次push到empty队列中，再进行删除，实现移动操作。
USB3.0接口——（2）数据结构
dkmknjk的博客
05-14 1063
在 USB 3.0 及更高版本的 xHCI 协议中，"Rings"、"Transfer Request Block (TRB)" 和 "Transfer Descriptor (TD)" 是用于管理 USB 数据传输和事件的重要概念。
「探索数据结构：了解顺序表」
2301_80321602的博客
05-17 527
顺序表是一种线性表的存储结构，它是由一组物理地址连续的存储单元（通常是数组）依次存储线性表中的元素。顺序表中的元素在内存中是连续存储的，通过元素在数组中的下标来访问和操作元素。顺序表的优点是访问元素的时间复杂度为O(1)，即可以通过下标直接访问元素，操作效率高；缺点是插入和删除元素时需要移动其他元素，时间复杂度为O(n)，效率较低。首先，我们需要定义动态顺序表的数据类型SLDataType和结构体SeqList。动态顺序表使用数组arr存储数据，size表示当前有效数据个数，capacity。
“ 树 ” 的概念
2401_82669797的博客
05-14 687
通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。：若一个结点含有子结点，则这个结点称为其子结点的父结点；：以某结点为根的子树中任一结点都称为该结点的子孙。：一个结点含有的子树的根结点称为该结点的子结点；具有相同父结点的结点互称为兄弟结点；：一个结点含有的子树的个数称为该结点的度；：从根开始定义起，根为第1层，根的子结点为第2层，以此类推；
线性表、栈和队列都是什么结构
05-15
线性表、栈和队列都是数据结构中常用的基本数据类型。 线性表是指数据元素之间存在一对一的线性关系，即除了第一个和最后一个元素，其它每个元素都恰好有一个前驱和一个后继。线性表可以用顺序存储结构和链式存储...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值