数据结构----栈和队列

最新推荐文章于 2024-06-14 05:45:37 发布
最新推荐文章于 2024-06-14 05:45:37 发布
阅读量124 收藏
点赞数
文章标签： 队列 leetcode 数据结构 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weijie_win/article/details/115357913
版权

1.顺序表实现

在这里插入图片描述

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

//顺序结构实现：实现一个更简单的顺序表
//可以调用顺序表接口来实现
typedef struct stack
{
	STDataType* _data;
	int _size;
	int _capacity;
}stack;

void initStack(stack* st)
{
	//空栈
	if (st == NULL)
		return;
	st->_data = NULL;
	st->_size = st->_capacity = 0;
}
void checkCapacity(stack* st)
{
	if (st->_size == st->_capacity)
	{
		int newCap = st->_capacity == 0 ? 1 : 2 * st->_capacity;
		st->_data = (STDataType*)realloc(st->_data,sizeof(STDataType)*newCap);
		st->_capacity = newCap;
	
	}
}
void stackPush(stack* st, STDataType val)//入栈
{
	//尾插
	if (st == NULL)
		return;
	checkCapacity(st);
	st->_data[st->_size++] = val;
}
void stackPop(stack* st)
{
	//尾删
	if (st == NULL || st->_size == 0)
		return;
	--st->_size;

}
int stackSize(stack* st)
{
	if (st == NULL)
		return 0;
	return st->_size;
}
int stackEmpty(stack* st)
{
	if (st == NULL || st->_size)
		return 1;
	else
		return 0;
	
}
STDataType stackTop(stack* st)
{
	return st->_data[st->_size - 1];
}



void test()
{
	stack st;
	initStack(&st);
}
int main()
{
	test();
	return 0;
}

2.队列

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

在这里插入图片描述
不带头非循环单向（头尾指针）
入队:尾插
出队：头删

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

//队列：带有尾指针的单链表

typedef int QDaTaType;
typedef struct QNode
{
	QDaTaType _data;
	struct QNode* _next;
};

typedef struct Queue
{
	//头尾指针
	struct QNode* _head;
	struct QNode* _tail;
	int _size;
}Queue;

void initQueue(Queue* q)
{
	//空队列
	if (q == NULL)
		return;
	q->_head = q->_tail = NULL;
	q->_size = 0;
}

struct QNode* creatNode(QDaTaType val)
{
	struct QNode* node = (struct QNode*)malloc(sizeof(struct QNode));
	node->_data = val;
	node->_next = NULL;
}
void queuePush(Queue* q, QDaTaType val)//入队
{	
	if (q == NULL)
		return;
	//尾插
	struct QNode* node = creatNode(val);
	//第一个节点
	if (q->_head == NULL)
		q->_head = q->_tail = node;
	else
	{
		q->_tail->_next = node;
		q->_tail = node;
	}
	++q->_size;
}

void queuePop(Queue* q)//出队
{
	if (q == NULL || q->_head == NULL)
		return;
	//头删
	struct QNode *next = q->_head->_next;
	free(q->_head);
	q->_head = next;
	if (q->_head == NULL)
		q->_tail = NULL;//空队列
	--q->_size;
}

QDaTaType queueFront(Queue* q)
{
	return q->_head->_data;
}

QDaTaType queueBack(Queue* q)
{
	return q->_tail->_data;
}

int queueEmpty(Queue* q)
{
	return q->_head == NULL; 
}

int queueSize(Queue* q)
{
	if (q == NULL)
		return 0;
	return q->_size;
	//遍历
}
void test()
{
	struct Queue q;
	initQueue(&q);
}

栈和队列面试题

1. 括号匹配问题。

bool isValid(char * s)
{
    //用栈实现
    int map[3][2]={{'(',')'},{'[',']'},{'{','}'}};
    int n=strlen(s);
    int stk[n+1];
    int top=0;
    if(n%2==1)
    return false;
    while(*s)
    {
        int flag=0;
        //左括号：入栈
        for(int i=0;i<3;++i)
        {
            if(*s==map[i][0])
            {
                stk[top++]=*s;
                //判断下一个
                ++s;
                flag=1;
                break;
            }
        }
        //右括号
        if(flag==0)
        {
            if(top==0)
            return false;//空栈无法取出元素，故必须要判断
            //取出栈顶元素
        int topChar=stk[top-1];
            --top;
            //找出当前字符*s对应的左括号
            for(int i=0;i<3;++i)
            {
                if(map[i][1]==*s)
                {
                    if(topChar==map[i][0])
                    {
                        //判断下一个字符
                        ++s;
                        break;
                    }
                    else
                    return false;
                }
            }
        }

bool isValid(char * s)
{
   char arr[128]={0};
    arr[')']='(';
    arr[']']='[';
    arr['}']='{';//右边映射左边
    int n=strlen(s);
    int stk[n+1];
    int top=0;
    while(*s)
    {
        int flag=0;
        if(*s=='('||*s=='['||*s=='{')
        {
            stk[top++]=*s;
            ++s;
            flag=1;
        }
        //右括号
        if(flag==0)
        {
            
            if(top==0)
            return false;
            //取出栈顶
            char topChar=stk[top-1];
            --top;
            if(arr[*s]==topChar)
            {
            ++s;
            }
            else
            return false;

        }
    }
    return top==0;
}

2. 用队列实现栈。

一个队列的做法

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

//队列：带有尾指针的单链表

typedef int QDaTaType;
typedef struct QNode
{
	QDaTaType _data;
	struct QNode* _next;
}QNode;

typedef struct Queue
{
	//头尾指针
	struct QNode* _head;
	struct QNode* _tail;
	int _size;
}Queue;

void initQueue(Queue* q)
{
	//空队列
	if (q == NULL)
		return;
	q->_head = q->_tail = NULL;
	q->_size = 0;
}

struct QNode* creatNode(QDaTaType val)
{
	struct QNode* node = (struct QNode*)malloc(sizeof(struct QNode));
	node->_data = val;
	node->_next = NULL;
    return node;
}
void queuePush(Queue* q, QDaTaType val)//入队
{	
	if (q == NULL)
		return;
	//尾插
	struct QNode* node = creatNode(val);
	//第一个节点
	if (q->_head == NULL)
		q->_head = q->_tail = node;
	else
	{
		q->_tail->_next = node;
		q->_tail = node;
	}
	++q->_size;
}

void queuePop(Queue* q)//出队
{
	if (q == NULL || q->_head == NULL)
		return;
	//头删
	struct QNode *next = q->_head->_next;
	free(q->_head);
	q->_head = next;
	if (q->_head == NULL)
		q->_tail = NULL;//空队列
	--q->_size;
}

QDaTaType queueFront(Queue* q)
{
	return q->_head->_data;
}

QDaTaType queueBack(Queue* q)
{
	return q->_tail->_data;
}

int queueEmpty(Queue* q)
{
	return q->_head == NULL; 
}

int queueSize(Queue* q)
{
	if (q == NULL)
		return 0;
	return q->_size;
	//遍历
}

void queueDestroy(Queue* q)
{
    QNode* cur=q->_head;
    while(cur)
    {
        QNode* next=cur->_next;
        free(cur);
        cur=next;
    }
    q->_head=q->_tail=NULL;
}


typedef struct {
    //队列成员
    struct Queue q;//定义一个q的队列

} MyStack;

/** Initialize your data structure here. */

MyStack* myStackCreate() {
    //动态创建
    MyStack* pst=(MyStack*)malloc(sizeof(MyStack));//栈上的结构体变量
    initQueue(&pst->q);//结构体变量的成员
    return pst;
}

/** Push element x onto stack. */
void myStackPush(MyStack* obj, int x) {
   queuePush(&obj->q,x);

}

/** Removes the element on top of the stack and returns that element. */
//一个队列的做法
int myStackPop(MyStack* obj) {//出队
  
    int n=queueSize(&obj->q);
    while(n>1)
    {
        //出队，入队
        int front=queueFront(&obj->q);//队头元素
        queuePop(&obj->q);
        queuePush(&obj->q,front);
        --n;
    }
    int top=queueFront(&obj->q);
    queuePop(&obj->q);
    return top;
}

/** Get the top element. */
int myStackTop(MyStack* obj) {
    return queueBack(&obj->q);
}

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

void myStackFree(MyStack* obj) {
    queueDestroy(&obj->q);
    free(obj);
}

两个队列的做法

typedef struct {
    struct Queue q1;
    struct Queue q2;

} MyStack;

/** Initialize your data structure here. */

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

/** 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) {
    int top;
    if(!queueEmpty(&obj->q1))
    {
        int n=queueSize(&obj->q1);
        while(n>1)
        {
            //出队，入队
            int front=queueFront(&obj->q1);
            queuePop(&obj->q1);
            queuePush(&obj->q2,front);
            --n;

        }
         top=queueFront(&obj->q1);
        queuePop(&obj->q1);
    }
    else
    {
        int n=queueSize(&obj->q2);
        while(n>1)
        {
            int front=queueFront(&obj->q2);
            queuePop(&obj->q2);
            queuePush(&obj->q1,front);
            --n;
        }
        top=queueFront(&obj->q2);
        queuePop(&obj->q2);
    }
    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);
}

3. 用栈实现队列

在这里插入图片描述

4. 设计循环队列.

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


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

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->_front==obj->_rear; 
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    //rear+1  %  空间的长度
    return (obj->_rear+1)%(obj->_k+1)==obj->_front;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
   //队列已满，不能入队
   if(myCircularQueueIsFull(obj))
    return false;
   //队尾入队
    obj->_data[obj->_rear++]=value;
    //判断队尾是否越界[0,k]
    if(obj->_rear>obj->_k)
    obj->_rear=0;
    return true;
}

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

    //判断队头是否越界
    if(obj->_front>obj->_k)
    obj->_front=0;
    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
    //rear为0，队尾元素在数组的末尾
        return obj->_data[obj->_k];

}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->_data);//队列当中数组的空间
    free(obj);//队列空间
}


//给有效元素的做法fa


```c

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

    int _size;//有效元素的个数
} MyCircularQueue;


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 myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->_size==0;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
  
    return obj->_size==obj->_k;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
   //队列已满，不能入队
   if(myCircularQueueIsFull(obj))
    return false;
   //队尾入队
    obj->_data[obj->_rear++]=value;
    //判断队尾是否越界[0,k)
    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
    //rear为0，队尾元素在数组的末尾
        return obj->_data[obj->_k-1];

}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->_data);//队列当中数组的空间
    free(obj);//队列空间
}
weijie_win
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构-栈和队列-PPT
02-04
"数据结构-栈和队列-PPT" 数据结构中栈和队列是两种常用的线性表结构，下面对它们的定义、特点和应用进行详细介绍。 栈的定义和特点 栈是一种只能在一端（栈顶）进行插入和删除运算的线性表。栈的逻辑结构与...
数据结构-栈与队列
01-07
数据结构-栈与队列一、顺序栈1.顺序栈的定义2：入栈二、顺序队列1：顺序栈的定义2：入队3：出队三、链队列1：链队列的定义：2：入队3：出队 一、顺序栈 1.顺序栈的定义 #define MaxSize 64 /* const int MaxSize =64...
数据结构与算法4—队列
yzwfeng的专栏
01-12 468
（1）表示空队列， rear==front==0。（4）A出队后，rear==front==3。再插入元素时，会出现假溢出的情况。3．出队列 OutQueue(&Q,&e) 将队列Q的队头元素删除，并用e返回其值，也称“退队”、“删除”。循环队列的物理存储未发生任何改变，其只是充分利用数组空间，想象将数组的首尾连接起来，形成一个循环队列。（c）B，C依次入队后， rear==3， front==0。（b）元素A入队后， rear==1， front==0。（a）表示空队列， rear==front==0。
第七章：C语言数据结构与算法初阶之队列
yanyongfu523的博客
03-11 286
队列：只允许在一端进行插入数据，在另一端进行删除数据操作的特殊线性表。
数据结构-队列和栈有什么区别
readerss的博客
08-28 1197
数据结构-队列和栈有什么区别 1：队列和栈是两种不同的数据结构。它们有以下区别： （1）操作的名称不同。队列的插入称为入队，队列的删除称为出队。栈的插入称为进栈，栈的删除称为出栈。 （2）可操作的方式不同。队列是在队尾入队，队头出队，即两边都可操作。而栈的进栈和出栈都是在栈顶进行的，无法对栈底直接进行操作。 （3）操作的方法不同。队列是先进先出（FIFO），即队列的修改是依先进先出的原则进行的。新...
数据结构-栈和队列
Wang3260584290的博客
11-17 769
栈和队列
线性结构 -- 栈和队列
柳絮
10-18 3152
线性结构 – 栈和队列 线性结构是一个有序数据元素的集合。 常用的线性结构有：线性表，栈，队列，双队列，数组，串。 常见的非线性结构有：二维数组，多维数组，广义表，树(二叉树等)，图。 特征： 1．集合中必存在唯一的一个"第一个元素"； 2．集合中必存在唯一的一个"最后的元素"； 3．除最后元素之外，其它数据元素均有唯一的"后继"； 4．除第一元素之外，其它数据元素均有唯一的"前驱"。 数据结构...
数据结构 --- 栈和队列
weixin_52625645的博客
10-10 906
栈和队列基础知识
数据结构--栈，队列
includeevey的博客
08-08 1929
一篇好的文章离不开你的观看
数据结构-栈和队列篇
qq_44663230的博客
09-05 1745
栈和队列思维导图+栈和队列习题
数据结构---栈和队列
weixin_63219391的博客
03-06 1002
本文介绍了栈和队列的概念和结构，文内包含栈和队列的实现代码，以及扩展：使用队列实现栈和使用栈实现队列。
c语言数据结构-栈队列数组完美版资料.ppt
11-14
本资源摘要信息主要关于C语言数据结构中的栈、队列和数组三个基本概念。...栈、队列和数组是C语言数据结构中的三个基本概念，栈的实现需要考虑到实际情况，栈的应用非常广泛，栈的优点和缺点需要被正确地考虑。
数据结构-栈和队列的使用
03-25
数据结构， 栈和队列的C语言用法； 包含基本原理以及使用的C语言例程，方便快捷
数据结构学习-队列/栈
04-28
简单的介绍了队列的实现原理，和一些开发中的考量
Golang | Leetcode Golang题解之第149题直线上最多的点数
weixin_66442839的博客
06-14 391
Golang | Leetcode Golang题解之第149题直线上最多的点数
【回溯】Leetcode 77. 组合【中等】
FLGB
06-11 263
你可以按 任何顺序 返回答案。
【代码随想录算法训练Day35】LeetCode 1005. K 次取反后最大化的数组和、LeetCode 134.加油站、LeetCode 135.分发糖果
qq_46121420的博客
06-11 234
贪心第三天
Java | Leetcode Java题解之第149题直线上最多的点数
最新发布
m0_57195758的博客
06-14 300
Java | Leetcode Java题解之第149题直线上最多的点数
数据结构----单向链表
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一...单向链表常用于需要频繁插入和删除操作的场景，比如实现栈、队列等数据结构，也可以用于实现其他高级数据结构，如图、树等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值