初阶数据结构：栈与队列的扩展补充

目录

  • 1. 栈与队列练习题
    • 1.1 栈的括号匹配问题
    • 1.2 用队列来实现栈
    • 1.3 用栈来实现队列
    • 1.4 扩展：循环队列

1. 栈与队列练习题

1.1 栈的括号匹配问题

  1. 题目信息：
    在这里插入图片描述
  2. 题目链接：
    括号匹配问题

思路： 利用栈的后进先出特性来实现括号的匹配

  1. 当遇到 ‘(’，‘{’，‘[’，这三种括号时进行压栈
  2. 当遇到’)‘，’}‘，’]'，这三种括号时将括号中的元素进行出栈匹配

过程演示：

在这里插入图片描述

typedef char STDataType;
typedef struct Stack
{STDataType* _a;int _top; // 栈顶int _capacity; // 容量
}Stack;void CheckCapacity(Stack* ps)
{if (ps->_capacity == ps->_top){int newcapacity = ps->_capacity == 0 ? 4 : 2 * ps->_capacity;STDataType* data = (STDataType*)realloc(ps->_a, newcapacity * sizeof(STDataType));if (data == NULL){perror("realloc failed");exit(-1);}ps->_a = data;ps->_capacity = newcapacity;}
}void StackInit(Stack* ps)
{ps->_capacity = 0;ps->_top = 0;ps->_a = NULL;CheckCapacity(ps);
}void StackPush(Stack* ps, STDataType data)
{assert(ps);CheckCapacity(ps);ps->_a[ps->_top] = data;ps->_top++;
}int StackEmpty(Stack* ps)
{assert(ps);return ps->_top == 0;
}void StackPop(Stack* 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;
}void StackDestroy(Stack* ps)
{assert(ps);free(ps->_a);ps->_capacity = ps->_top = 0;
}bool isValid(char* s) 
{Stack st1;StackInit(&st1);int i = 0;for(i = 0; s[i] != '\0'; i++){if(s[i] == '(' || s[i] == '[' || s[i] == '{'){StackPush(&st1, s[i]);}else if(s[i] == ')' || s[i] == ']' || s[i] == '}'){if(StackEmpty(&st1)){return false;}char tmp = StackTop(&st1);if(s[i] == ')' && tmp == '('){StackPop(&st1);}else if(s[i] == ']' && tmp == '['){StackPop(&st1);}else if(s[i] == '}' && tmp == '{'){StackPop(&st1);}else{break;}}}if(StackEmpty(&st1)){return true;}return false;      
}

1.2 用队列来实现栈

  1. 题目信息：
    在这里插入图片描述
  2. 题目链接：
    用两个队列实现栈

在这里插入图片描述

myStack结构：
在这里插入图片描述

typedef int QDataType;typedef struct QListNode
{struct QListNode* _pNext;QDataType _data;
}QNode;typedef struct Queue
{QNode* _front;QNode* _rear;
}Queue;void QueueInit(Queue* q)
{assert(q);q->_front = q->_rear = NULL;
}QNode* BuyNewNode2(QDataType data)
{QNode* newnode = (QNode*)malloc(sizeof(QNode));if (newnode == NULL){perror("malloc failed");exit(-1);}newnode->_data = data;newnode->_pNext = NULL;return newnode;
}void QueuePush(Queue* q, QDataType data)
{assert(q);QNode* newnode = BuyNewNode2(data);if (q->_front == NULL){q->_front = q->_rear = newnode;}else{q->_rear->_pNext = newnode;q->_rear = q->_rear->_pNext;}
}int QueueEmpty(Queue* q)
{assert(q);return q->_front == NULL;
}void QueuePop(Queue* q)
{assert(q);assert(!QueueEmpty(q));QNode* cur = q->_front->_pNext;free(q->_front);q->_front = cur;if (q->_front == NULL){q->_rear = NULL;}
}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);int count = 0;QNode* cur = q->_front;while (cur){cur = cur->_pNext;count++;}return count;
}void QueueDestroy(Queue* q)
{assert(q);while (q->_front){QueuePop(q);}
}typedef struct MyStack
{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)
{assert(obj);Queue* no_empty = &obj->q1;if (QueueEmpty(&obj->q1)){no_empty = &obj->q2;}QueuePush(no_empty, x);
}bool myStackEmpty(MyStack* obj)
{assert(obj);return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}int myStackTop(MyStack* obj)
{assert(obj);assert(!myStackEmpty(obj));Queue* no_empty = &obj->q1;if (QueueEmpty(&obj->q1)){no_empty = &obj->q2;}return QueueBack(no_empty);
}int myStackPop(MyStack* obj)
{Queue* no_empty = &obj->q1;Queue* empty = &obj->q2;if (QueueEmpty(&obj->q1)){no_empty = &obj->q2;empty = &obj->q1;}while (QueueSize(no_empty) > 1){QueuePush(empty, QueueFront(no_empty));QueuePop(no_empty);}int val = QueueFront(no_empty);QueuePop(no_empty);return val;
}void myStackFree(MyStack* obj)
{assert(obj);Queue* no_empty = &obj->q1;if (QueueEmpty(&obj->q1)){no_empty = &obj->q2;}QueueDestroy(no_empty);free(obj);
}

1.3 用栈来实现队列

  1. 题目信息：
    在这里插入图片描述
  2. 题目链接：
    用栈实现队列

过程演示：
在这里插入图片描述

typedef char STDataType;
typedef struct Stack
{STDataType* _a;int _top; // 栈顶int _capacity; // 容量
}Stack;void CheckCapacity(Stack* ps)
{if (ps->_capacity == ps->_top){int newcapacity = ps->_capacity == 0 ? 4 : 2 * ps->_capacity;STDataType* data = (STDataType*)realloc(ps->_a, newcapacity * sizeof(STDataType));if (data == NULL){perror("realloc failed");exit(-1);}ps->_a = data;ps->_capacity = newcapacity;}
}void StackInit(Stack* ps)
{ps->_capacity = 0;ps->_top = 0;ps->_a = NULL;CheckCapacity(ps);
}void StackPush(Stack* ps, STDataType data)
{assert(ps);CheckCapacity(ps);ps->_a[ps->_top] = data;ps->_top++;
}int StackEmpty(Stack* ps)
{assert(ps);return ps->_top == 0;
}void StackPop(Stack* 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;
}void StackDestroy(Stack* ps)
{assert(ps);free(ps->_a);ps->_capacity = ps->_top = 0;
}typedef struct 
{Stack push_stack;Stack pop_stack;    
} MyQueue;MyQueue* myQueueCreate() 
{MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));StackInit(&obj->push_stack);StackInit(&obj->pop_stack);return obj;    
}void myQueuePush(MyQueue* obj, int x) 
{assert(obj);StackPush(&obj->push_stack, x);    
}bool myQueueEmpty(MyQueue* obj) 
{assert(obj);return StackEmpty(&obj->push_stack) && StackEmpty(&obj->pop_stack);
}int myQueuePeek(MyQueue* obj) 
{assert(obj);assert(!myQueueEmpty(obj));if(StackEmpty(&obj->pop_stack)){while(!StackEmpty(&obj->push_stack)){StackPush(&obj->pop_stack, StackTop(&obj->push_stack));StackPop(&obj->push_stack);}}return StackTop(&obj->pop_stack);
}int myQueuePop(MyQueue* obj) 
{assert(obj);assert(!myQueueEmpty(obj));int data = myQueuePeek(obj);StackPop(&obj->pop_stack);return data;
}void myQueueFree(MyQueue* obj) 
{assert(obj);StackDestroy(&obj->push_stack);StackDestroy(&obj->pop_stack);free(obj);    
}

1.4 扩展：循环队列

  1. 题目信息：
    在这里插入图片描述
  2. 题目链接：
    循环链表

过程演示：
在这里插入图片描述

typedef struct
{int* data;int c_front;int c_rear;int capacity_k;
} MyCircularQueue;MyCircularQueue* myCircularQueueCreate(int k)
{MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));//k + 1为构建循环链表所需的空间大小obj->data = (int*)malloc((k + 1) * sizeof(int));//注：k为能够存储的元素个数，即链表存储数据的容量obj->capacity_k = k;obj->c_front = obj->c_rear = 0;return obj;
}bool myCircularQueueIsFull(MyCircularQueue* obj)
{assert(obj);int k = obj->capacity_k;return obj->c_front % (k + 1) == (obj->c_rear + 1) % (k + 1);
}bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)
{assert(obj);int k = obj->capacity_k;if (!myCircularQueueIsFull(obj)){int rear = obj->c_rear % (k + 1);obj->data[rear] = value;obj->c_rear++;return true;}return false;
}bool myCircularQueueIsEmpty(MyCircularQueue* obj)
{assert(obj);int k = obj->capacity_k;return obj->c_front % (k + 1) == obj->c_rear % (k + 1);
}bool myCircularQueueDeQueue(MyCircularQueue* obj)
{assert(obj);if (!myCircularQueueIsEmpty(obj)){obj->c_front++;return true;}return false;
}int myCircularQueueFront(MyCircularQueue* obj)
{assert(obj);int k = obj->capacity_k;if (!myCircularQueueIsEmpty(obj)){int front = obj->c_front % (k + 1);return obj->data[front];}return -1;
}int myCircularQueueRear(MyCircularQueue* obj)
{assert(obj);int k = obj->capacity_k;if (!myCircularQueueIsEmpty(obj)){int pre_rear = (obj->c_rear - 1) % (k + 1);return obj->data[pre_rear];}return -1;
}void myCircularQueueFree(MyCircularQueue* obj)
{assert(obj);free(obj->data);free(obj);
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/502520.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

JAVASE初认识

JAVASE初认识

1.初认识其结构 1.源文件（扩展名为*.java)：源文件带有类的定义。类用来表示程序的一个组件，小程序或许只会有一个类。类的内容必须包含在花括号里面。 2.类：类中带有一个或多个方法。方法必须在类的内部声明。 3.方法&#xff1…
阅读更多...
解决微软活动目录管理工作中常见问题

解决微软活动目录管理工作中常见问题

微软活动目录（AD域）是一种由微软的用于管理网络中用户、计算机、资源等的目录服务。活动目录被广泛应用于企业内部的网络管理中，尤其是对于使用微软产品的企业来说，活动目录是至关重要的基础设施之一。 因此，以微软为…
阅读更多...
ChatGpt 使用fetch-event-source实现sse流式处理

ChatGpt 使用fetch-event-source实现sse流式处理

microsoft/fetch-event-source 是一个由微软提供的库，用于在客户端和服务器之间建立基于 EventSource 的连接。EventSource 是一种 HTTP 协议，允许服务器向客户端推送实时事件流。该库提供了对 EventSource 协议的封装，使得在前端 JavaScript…
阅读更多...
旧衣回收小程序开发，提高回收效率增加创收

旧衣回收小程序开发，提高回收效率增加创收

在我国经济大力发展下，国人的生活水平不断提高。生活质量得到提升，衣食住行也从而得到了提升。因此，家家户户中产生的闲置衣物开始增加，我国旧衣回收市场规模非常庞大。 当下，时代发展主流是以互联网为主，…
阅读更多...
项目-SERVER模块-Socket模块

项目-SERVER模块-Socket模块

Socket模块 一、Socket模块是什么？二、代码实现1.成员变量2.构造、析构函数3.获取套接字文件描述符4.创建套接字5.绑定地址信息6.开始监听连接请求7.向服务器发起连接8.获取新连接9.接收数据10.非阻塞接收数据11.发送数据12.非阻塞发送数据13.关闭套接字14.创建一个…
阅读更多...
神经网络系列---卷积

神经网络系列---卷积

文章目录 卷积神经网络卷积转置卷积 卷积核和反卷积的三种实现方式卷积的次数计算 卷积神经网络 在神经网络的卷积层中，向下取整（Floor）是一种常用的策略，特别是在处理输出尺寸不是整数的情况时。当你计算出卷积层输出的尺寸&…
阅读更多...
深入了解接口测试：方法、工具和关键考虑因素

深入了解接口测试：方法、工具和关键考虑因素

接口测试是软件测试中的一项重要工作，它涉及到系统与系统之间的交互点。接口可以是外部接口，也可以是内部接口，包括上层服务与下层服务接口以及同级接口。在接口测试中，我们需要确保接口能够按照预期的方式进行通信和交互&#xf…
阅读更多...
二叉树（Java）

二叉树（Java）

目录 一、概念二、 两种特殊的二叉树三、 二叉树的性质四、二叉树的存储五、二叉树的基本操作1、二叉树的遍历（1）前中后序遍历（2）层序遍历 2、基本操作 六、总结 一、概念 一棵二叉树是结点的一个有限集合，该集合&…
阅读更多...
xsslabs第六关

xsslabs第六关

看一下源码 <!DOCTYPE html><!--STATUS OK--><html> <head> <meta http-equiv"content-type" content"text/html;charsetutf-8"> <script> window.alert function() { confirm("完成的不错&#xff01;…
阅读更多...
驱动高级--mknod

驱动高级--mknod

一、起源 仅devfs&#xff0c;导致开发不方便以及一些功能难以支持&#xff1a; 热插拔 不支持一些针对所有设备的统一操作&#xff08;如电源管理&#xff09; 不能自动mknod 用户查看不了设备信息 设备信息硬编码&#xff0c;导致驱动代码通用性差&#xff0c;即没有分离…
阅读更多...
JavaScript DOM操作笔记记录回忆总结

JavaScript DOM操作笔记记录回忆总结

一、什么是DOM&#xff1f; 1、通过 HTML DOM&#xff0c;可访问 JavaScript HTML 文档的所有元素。 2、当网页被加载时&#xff0c;浏览器会创建页面的文档对象模型&#xff08;Document Object Model&#xff09; 二、操作DOM 1、在操作DOM之前&#xff0c;我们需要先获取到…
阅读更多...
vue自定义实现icon选择器

vue自定义实现icon选择器

<template> <div> <span class"iconStyle" click"selectIcon"> <i :class"value" /> </span> <div class"iconTitle">选择图标</div> <el-dialog title"" :visible.sync"…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023