栈与队列的相爱相杀

最新推荐文章于 2022-07-21 15:54:26 发布
原创 最新推荐文章于 2022-07-21 15:54:26 发布 · 222 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 

typedef char Type;

typedef struct Stack
{
	Type* _array;
	size_t _size;
	size_t _capacity;
}Stack;

void stackInit(Stack* st, size_t n);

void stackPush(Stack* st, Type data);
void stackPop(Stack* st);
Type stackTop(Stack* st);

size_t stackSize(Stack* st);
int stackEmpty(Stack* st);

void stackDestory(Stack* st);

void stackInit(Stack* st, size_t n)
{
	st->_array = (Type*)malloc(sizeof(Type)* n);
	st->_capacity = n;
	st->_size = 0;
}

void stackPush(Stack* st, Type data)
{
	//检查容量
	if (st->_size == st->_capacity)
	{
		st->_capacity *= 2;
		st->_array = (Type*)realloc(st->_array, st->_capacity * sizeof(Type));
	}
	//尾插
	st->_array[st->_size++] = data;
}
void stackPop(Stack* st)
{
	//尾删
	if (st->_size)
		--st->_size;
}
Type stackTop(Stack* st)
{
	return st->_array[st->_size - 1];
}

size_t stackSize(Stack* st)
{
	return st->_size;
}
int stackEmpty(Stack* st)
{
	if (st->_size == 0)
		return 1;
	return 0;
}

void stackDestory(Stack* st)
{
	free(st->_array);
	st->_array = NULL;
	st->_size = st->_capacity = 0;
}

bool isValid(char * s){
    //左右括号的映射
    static char map[][2] = {{'(', ')'},
     {'[', ']'}, {'{', '}'}};
    Stack st;
    stackInit(&st, 10);
    
    //遍历字符串， 左括号入栈， 右括号匹配
    while(*s)
    {
        int i = 0;
        //flag: 是否找到一个左括号
        int flag = 0;
        //判断是否为左括号
        for(; i < 3;++i)
        {
            if(*s == map[i][0])
            {
                //左括号入栈
                stackPush(&st, *s);
                ++s;
                flag = 1;
                break;
            }
        }
        //循环走完，说明不是一个左括号
        //if(i == 3)
        if(flag == 0)
        {
            //让当前的右括号匹配栈顶元素
            if(stackEmpty(&st))
                return false;
            char topChar = stackTop(&st);
        
            
            //找出对应的右括号在map的位置
            for(int j = 0; j < 3; ++j)
            {
                if(*s == map[j][1])
                {
                    if(topChar == map[j][0])
                    {
                        //左右匹配
                        stackPop(&st);
                        ++s;
                        break;
                    }
                    else
                        return false;
                }
            }
            
        }

    }

    if(stackEmpty(&st))
        return true;
    return false;
}

typedef int QDataType;

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

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

void queueInit(Queue* q);

QNode* creatNode(QDataType data);

void queuePush(Queue* q, QDataType data);

void queuePop(Queue* q);

QDataType queueFront(Queue* q);

QDataType queueBack(Queue* q);

int queueSize(Queue* q);

int queueEmpty(Queue* q);

void queueDestory(Queue* q);

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

QNode* creatNode(QDataType data)
{
	QNode* node = (QNode*)malloc(sizeof(QNode));
	node->_data = data;
	node->_next = NULL;
	return node;
}
//队尾入队
void queuePush(Queue* q, QDataType data)
{
	QNode* node = creatNode(data);
	//空队列
	if (q->_front == NULL)
		q->_front = q->_rear = node;
	else
	{
		q->_rear->_next = node;
		q->_rear = node;
	}
	++q->_size;
}

//队头出队
void queuePop(Queue* q)
{
	if (q->_front)
	{
		QNode* next = q->_front->_next;
		free(q->_front);
		q->_front = next;
		//删除之后是否为空表
		if (q->_front == NULL)
			q->_rear = NULL;
		--q->_size;
	}
}

//获取队头元素
QDataType queueFront(Queue* q)
{
	return q->_front->_data;
}
//获取队尾元素
QDataType queueBack(Queue* q)
{
	return q->_rear->_data;
}

int queueSize(Queue* q)
{
	/*
	int num = 0;
	QNode* cur = q->_front;
	while (cur)
	{
		++num;
		cur = cur->_next;
	}
	return num;
	*/
	return q->_size;
}

int queueEmpty(Queue* q)
{
	if (q->_front == NULL)
		return 1;
	return 0;
}

void queueDestory(Queue* q)
{
	QNode* cur = q->_front;
	while (cur)
	{
		QNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	q->_front = q->_rear = NULL;
	q->_size = 0;
}



typedef struct {
    //一个队列实现
    Queue q;
} MyStack;

/** Initialize your data structure here. */

MyStack* myStackCreate() {
    MyStack* ms = (MyStack*) malloc(sizeof(MyStack));
    queueInit(&ms->q);
    return ms;
}

/** 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 ret;
    int size = queueSize(&obj->q);
    while(size > 1)
    {
        int front = queueFront(&obj->q);
        queuePop(&obj->q);
        queuePush(&obj->q, front);
        --size;
    }
    ret = queueFront(&obj->q);
    queuePop(&obj->q);
    return ret;
}

/** 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) {
    queueDestory(&obj->q);
    free(obj);
}


typedef int Type;

typedef struct Stack
{
	Type* _array;
	size_t _size;
	size_t _capacity;
}Stack;

void stackInit(Stack* st, size_t n);

void stackPush(Stack* st, Type data);
void stackPop(Stack* st);
Type stackTop(Stack* st);

size_t stackSize(Stack* st);
int stackEmpty(Stack* st);

void stackDestory(Stack* st);

void stackInit(Stack* st, size_t n)
{
	st->_array = (Type*)malloc(sizeof(Type)* n);
	st->_capacity = n;
	st->_size = 0;
}

void stackPush(Stack* st, Type data)
{
	//检查容量
	if (st->_size == st->_capacity)
	{
		st->_capacity *= 2;
		st->_array = (Type*)realloc(st->_array, st->_capacity * sizeof(Type));
	}
	//尾插
	st->_array[st->_size++] = data;
}
void stackPop(Stack* st)
{
	//尾删
	if (st->_size)
		--st->_size;
}
Type stackTop(Stack* st)
{
	return st->_array[st->_size - 1];
}

size_t stackSize(Stack* st)
{
	return st->_size;
}
int stackEmpty(Stack* st)
{
	if (st->_size == 0)
		return 1;
	return 0;
}

void stackDestory(Stack* st)
{
	free(st->_array);
	st->_array = NULL;
	st->_size = st->_capacity = 0;
}

typedef struct {
    Stack pushST;
    Stack popST;
} MyQueue;

/** Initialize your data structure here. */

MyQueue* myQueueCreate() {
    MyQueue* mq = (MyQueue*) malloc(sizeof(MyQueue));
    stackInit(&mq->pushST, 10);
    stackInit(&mq->popST, 10);
    return mq;
}

/** 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) {
    int ret;
    if(stackEmpty(&obj->popST))
    {
        while(stackEmpty(&obj->pushST) != 1)
        {
            int top = stackTop(&obj->pushST);
            stackPop(&obj->pushST);
            stackPush(&obj->popST, top);
        }
    }
    ret = stackTop(&obj->popST);
    stackPop(&obj->popST);
    return ret;
}

/** Get the front element. */
int myQueuePeek(MyQueue* obj) {
    if(stackEmpty(&obj->popST))
    {
        while(stackEmpty(&obj->pushST) != 1)
        {
            int top = stackTop(&obj->pushST);
            stackPop(&obj->pushST);
            stackPush(&obj->popST, top);
        }
    }
    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) {
    stackDestory(&obj->pushST);
    stackDestory(&obj->popST);
    free(obj);
}



typedef struct {
	int front;
	int rear;
	int size;
	int k;
	int* array;
} MyCircularQueue;

/** Initialize your data structure here. Set the size of the queue to be k. */

MyCircularQueue* myCircularQueueCreate(int k) {
	MyCircularQueue* mq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
	mq->array = (int*)malloc(sizeof(int)* k);
	mq->front = mq->rear = 0;
	mq->size = 0;
	mq->k = k;
	return mq;
}

/** Insert an element into the circular queue. Return true if the operation is successful. */
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
	if (obj->size == obj->k)
		return false;
	//尾插
	obj->array[obj->rear++] = value;
	//保证循环结构
	if (obj->rear == obj->k)
		obj->rear = 0;
	obj->size++;
	return true;
}

/** Delete an element from the circular queue. Return true if the operation is successful. */
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
	if (obj->size == 0)
		return false;
	//头删
	++obj->front;
	if (obj->front == obj->k)
		obj->front = 0;
	--obj->size;
	return true;
}

/** Get the front item from the queue. */
int myCircularQueueFront(MyCircularQueue* obj) {
	if (obj->size == 0)
		return -1;
	return obj->array[obj->front];
}

/** Get the last item from the queue. */
int myCircularQueueRear(MyCircularQueue* obj) {
	if (obj->size == 0)
		return -1;
	if (obj->rear == 0)
		return obj->array[obj->k - 1];
	return obj->array[obj->rear - 1];
}

/** Checks whether the circular queue is empty or not. */
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
	if (obj->size == 0)
		return true;
	return false;
}

/** Checks whether the circular queue is full or not. */
bool myCircularQueueIsFull(MyCircularQueue* obj) {
	if (obj->size == obj->k)
		return true;
	return false;
}

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

//第二种实现方式
typedef struct {
	int front;
	int rear;
	//int size;
	int k;
	int* array;
} MyCircularQueue;

/** Initialize your data structure here. Set the size of the queue to be k. */

MyCircularQueue* myCircularQueueCreate(int k) {
	MyCircularQueue* mq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
	mq->array = (int*)malloc(sizeof(int)* (k + 1));
	mq->front = mq->rear = 0;
	//mq->size = 0;
	mq->k = k;
	return mq;
}

/** Insert an element into the circular queue. Return true if the operation is successful. */
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
	if ((obj->rear + 1) % (obj->k + 1) == obj->front)
		return false;
	//尾插
	obj->array[obj->rear++] = value;
	//保证循环结构
	if (obj->rear == obj->k + 1)
		obj->rear = 0;
	//obj->size++;
	return true;
}

/** Delete an element from the circular queue. Return true if the operation is successful. */
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
	if (obj->front == obj->rear)
		return false;
	//头删
	++obj->front;
	if (obj->front == obj->k + 1)
		obj->front = 0;
	//--obj->size;
	return true;
}

/** Get the front item from the queue. */
int myCircularQueueFront(MyCircularQueue* obj) {
	if (obj->front == obj->rear)
		return -1;
	return obj->array[obj->front];
}

/** Get the last item from the queue. */
int myCircularQueueRear(MyCircularQueue* obj) {
	if (obj->front == obj->rear)
		return -1;
	if (obj->rear == 0)
		return obj->array[obj->k];
	return obj->array[obj->rear - 1];
}

/** Checks whether the circular queue is empty or not. */
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
	if (obj->front == obj->rear)
		return true;
	return false;
}

/** Checks whether the circular queue is full or not. */
bool myCircularQueueIsFull(MyCircularQueue* obj) {
	if ((obj->rear + 1) % (obj->k + 1) == obj->front)
		return true;
	return false;
}

void myCircularQueueFree(MyCircularQueue* obj) {
	free(obj->array);
	free(obj);
}
⑥ - 后端工程师通识指南
易编橙 · 终身成长社群，相遇已是上上签！
04-29 1539
就像是在上一章节介绍的那样，在互联网早期是没有前后端的说法的。技术相对简单，前端和后端的界限并不明显。但随着Web技术的不断发展和用户需求的日益复杂化，前后端分离的架构逐渐成为主流。这种架构将前端负责的用户界面和后端负责的数据处理与逻辑运算分开，使得两者能够更专注于自己的领域，并提高了开发效率。
编程实现顺序队列的入队操作和出队操作，并将出队结果输出
罗小黑の窝
02-10 7442
头文件：函数的声明 #include #include #include #define QUEUESIZE 100 typedef char ElemType; typedef struct { ElemType queue[QUEUESIZE]; int front; int rear; }SeqQueue; void InitQueue(SeqQueue *SQ); int
栈与队列的应用
￡滫&
12-05 1143
实验名称：栈与队列的应用 实验目的：通过实验理解栈和队列的应用 实验内容： 1、输入10个数，并按输入顺序入队，然后将它们逐个出队并输出。 2、输入一串字符，以#结束，利用栈和队列来判断它是否是回文。 3、编写递归函数，求正整数N的阶乘N!。 再编写一个函数，用栈实现求N的阶乘，体会栈与递归的关系。
顺序栈实现回文串
weixin_45326969的博客
03-20 1351
顺序栈实现回文串 题目描述 请你使用顺序栈编写symmetry函数实现判断一个字符串是否为回文 编写主函数调用子函数symmetry 同时对其中用到的功能段尽量用子函数来实现 输入描述 输入一串字符串，遇回车结束 输出描述 是回文或者不是回文 样例输入 asdffdsa 样例输出 是回文 判断代码 int huiwen(SElemType *a,int len) { SqStack s; SE...
队列和栈的使用
wangjieyunxia的专栏
05-25 449
都这个点，虽然很想回去，还是坚持下来写写总结，不然之前的努力就都白费了。 1、栈 加上“stack”的头文件，常用的函数有： stackp;  p.top（）；p.size（）；p.empty（）；p.push（）；p.pop（）； 2、队列 加上的头文件，常用的函数有： queueq; q.front（）；q.back（）；p.size（）；p.empty（）；p.push（）；
队列的入队、出队基本操作
热门推荐
leumber的专栏
10-17 4万+
队列先进先出的线性表（FIFO）队尾：队列中指定了用来插入数据的一端 队头：队列中指定了用来删除数据的一端 入队：数据的插入动作 出队：数据的删除动作 1.顺序队列//顺序队列 #define QUEUESIZE 64typedef struct _sequ { dataType data[QUEUESIZE]; int front; int rear; }SeQueue,*
Java 技术栈中间件优雅停机方案设计与实现全景图
m0_67322837的博客
07-21 402
复制代码.....自定义销毁方法....}}复制代码由于本文的主题是介绍优雅关闭的一整条流程主线，所以这里笔者只是简要介绍Dubbo优雅关闭的主流程，相关细节部分笔者会在后续的dubbo源码解析系列里为大家详细介绍Dubbo优雅关闭的细节。为了避免本文发散太多，我们这里还是聚焦于流程主线。destroy();}}复制代码这里的核心逻辑其实就是我们在《1.2优雅关闭》小节中介绍的两大优雅关闭主题从当前正在关闭的应用实例上切走现有生产流量。保证业务无损。try{...
JVM内核级解析：C1与C2编译器工作原理与线程调度机制（高级开发者必读）
# JVM内核架构与即时编译深度解析 在现代Java应用的性能战场上，虚拟机（JVM）早已不再是那个“一次编写、到处运行”的简单容器。它已经演变为一个高度智能化的运行时系统，能够动态感知程序行为，并做出最优化的...
内存管理底层真相曝光：MRC与autorelease池运作机制的深度解密
# 内存管理的演进之路：从MRC到ARC的深度解析 在iOS开发的世界里，内存管理就像空气一样无处不在却又常常被忽视——直到你突然“喘不过气”为止。 曾经有多少个深夜，我们盯着Xcode中不断攀升的内存曲线发呆？...
复杂中断嵌套中的断点管理：避免误触发与性能损耗的6大原则
# 复杂中断嵌套环境下的断点管理：从理论到实战的深度剖析 在现代嵌入式系统中，我们常常会遇到这样一个“诡异”的现象：明明只设了一个断点，程序却停了五六次；或者刚进入调试模式，系统就莫名其妙地崩溃了。...
建立一个顺序队列，实现队列的入队和出队操作
ab111996的博客
05-02 5992
头文件：  #ifndef seqqueue_H  #define seqqueue_H  const int queuesize=10;  class seqqueue   {      int rear,front;      int data[queuesize];  public:      seqqueue(){front=rear=queuesize-1;}      ~seqqu...
队列与栈的输入输出
weixin_30727835的博客
12-29 637
下面程序演示了队列FIFO和栈LIFO的行为 // fifolifo.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include <iostream> #include <string> #include <queue> #include <stack> using names...
（数据结构）建立循环队列，将一组数据入队，然后再分别出队并输
qq_46426180的博客
10-09 1458
#include <stdio.h> #define MAXSIZE 100 #define datatype char #define NULL '\0' typedef struct { datatype data[MAXSIZE]; int front,rear; }SEQUEUE; void initqueue(SEQUEUE *q) { q->front=-1; q->rear=-1; } void enqueue(SEQUEUE *q,datatype x)
顺序队列基本操作的实现----入队、出队、打印
haikuotiankong7的博客
11-23 7957
以顺序存储结构对队列进行操作----入队、出队、打印并判断队列现有长度（以类的形式） 程序如下： queue.h  头文件 #pragma once #include class queue { private: int *data; int tail, head, len; // head 用于删除，tail 用于加入新元素 public: queue(int inp
栈，队列的应用
weixin_30633405的博客
03-26 102
栈 1.计算文件的大小 # def get_size(path): # sum = 0 # l = [path] # while l : # path = l.pop() # lis = os.listdir(path) # for name in lis: # son_pat...
建立一个链队列，实现队列的入队和出队操作。
ab111996的博客
05-02 6110
#ifndef linkqueue_H  #define linkqueue_H  struct node  {      int data;      node *next;  };  class linkqueue  {  private:      node *front,*rear;  public:      linkqueue();      ~linkqueue();      ...
链队列的初始化、入队、出队等操作实现
weixin_34352005的博客
05-10 2381
链队列的初始化、入队、出队等基本操作实现代码如下：#include<iostream>using namespace std;#define TRUE 1#define FALSE 0//链队列定义typedef struct Node{ int data;//数据域 struct Node *next;//指针域}LinkQueueNode;typedef ...
数据结构 c语言实现顺序队列（输数字入队，字符出队）
不文东的博客
07-29 2633
一.头文件seqqueue.h实现 #ifndef __SEQQUEUE_H__ #define __SEQQUEUE_H__ #include #include #include #define MAXSIZE 64 typedef int datatype; typedef struct seqqueue {     datatype data[MAXSIZE];
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值