栈和队列的实现以及相关OJ题目
栈和队列的实现以及相关OJ题目
- 一、栈
-
- 1.栈的概念及结构
- 2.栈的动态实现
- 3.有关于栈的OJ题目
-
- 3.1括号匹配问题
- 二、队列
-
- 1.队列的概念以及结构
- 2.队列的实现
- 3.队列的OJ题目
-
- 3.1用队列实现栈
- 3.2用栈实现队列
- 3.3循环队列
- 总结
一、栈
1.栈的概念及结构
栈：是一种特殊的·线性表，其只允许在固定的一端进行插入和删除元素操作
进行数据插入和删除操作的一端成为栈顶，另一端成为栈底。
栈遵循的原则：是先进后出。
2.栈的动态实现
栈的实现一般可以使用数组或者链表来实现，相对而言数组的结构实现会更优， 因为在数组在尾上插入数据的代价比较小。
注意：栈不能遍历
常用操作的模拟实现：
初始化、入栈、出栈、获取元素的个数、判空、获取栈定元素。
我们实现的是支持动态增长的栈
.h文件
# pragma once
typedef int DataType;
typedef struct stack
{
DataType* arr;
int capacity;
//表示栈中有多少元素——栈顶
int size;
}stack;
//初始化栈
void StackInit(stack* ps);
//入栈
void StackPush(stack* ps, DataType data);
//出栈
void StackPop(stack* ps);
//获取栈顶元素
DataType StackTop(stack* ps);
//获取栈中有效个数
int StackSize(stack* ps);
//检测栈是否为空
int StackEmpty(stack* ps);
//销毁栈
void StackDestroy(stack* ps);
int Capacity(stack* ps);
.c文件
# include 3.有关于栈的OJ题目
3.1括号匹配问题
题目描述：
解题思路：
1.依次获取每个括号
2.检测该括号是左括号还是右括号
是左括号则入栈
是右括号----如果是有效匹配则之前一定有和之匹配的左括号
3.检测该括号和栈顶的括号是否匹配
)和( }和{ ]和[
匹配的话：栈顶的左括号出栈
否则：括号不匹配
程序部分：
核心代码
bool isValid(char * s)
{
bool flag=false;
stack st;
StackInit(&st);
//"(" ")"
for(int i=0;i<strlen(s);++i)
{
//如果是左括号，
if('('==s[i]||'['==s[i]||'{'==s[i])
{
//入栈
StackPush(&st,s[i]);
}
else
{
//如果拿到右括号
//但是栈刚好是空的
if(StackEmpty(&st))
{
StackDestroy(&st);
return false;
}
//检测该括号和栈顶的括号是否匹配
char top=StackTop(&st);
if(s[i]==')'&&top=='('||
s[i]==']'&&top=='['||
s[i]=='}'&&top=='{')
{
StackPop(&st);
}
else
{
break;
}
}
}
if(StackEmpty(&st))
{
flag=true;
}
StackDestroy(&st);
return flag;
}
二、队列
1.队列的概念以及结构
队列：只允许在一端进行插入数据的操作，在另一端进行数据删除的特殊线性表。进行插入一端称为队尾；进行删除的一段成为队头。
遵循原则：先进先出
2.队列的实现
队列也可以用数组和链表结构实现，不过在使用链表的结构实现更好，因为，使用数组的结构，出队列的效率会比较低。
入队列的操作时间复杂度尾 O(N)，因为需要将元素整体搬移。
所以这里采用带头单向链表实现队列：
核心代码
.h文件
#pragma once
// 此处采用带头单链表来实现队列
typedef int DataType;
//节点的结构
typedef struct QNode
{
struct QNode* next;
DataType data;
}QNode;
//队列的结构
typedef struct Queue
{
QNode* front;
QNode* rear;
}Queue;
//队列的初始化
void QueueInit(Queue* q);
// 入队列
void QueuePush(Queue* q, DataType data);
// 出队列
void QueuePop(Queue* q);
// 获取队头元素
DataType QueueFront(Queue* q);
// 获取队尾元素
DataType QueueBack(Queue* q);
// 获取队列中有效元素的个数
int QueueSize(Queue* q);
// 检测队列是否为空
int QueueEmpty(Queue* q);
// 将队列销毁掉
void QueueDestroy(Queue* q);
void TestQueue();
.c文件
#include "DLList.h"
#include 3.队列的OJ题目
3.1用队列实现栈
题目描述：
解题思路：
该题的思路我用图文加文字的形式：
程序部分：
核心代码
typedef struct {
Queue q1;
Queue q2;
} MyStack;
/** Initialize your data structure here. */
MyStack* myStackCreate() {
//这个位置需要用malloc从堆上开辟空间
MyStack* ms=(MyStack*)malloc(sizeof(MyStack));
if(NULL==ms)
{
return NULL;
}
QueueInit(&ms->q1);
QueueInit(&ms->q2);
return ms;
}
//入栈
/** 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 ret=0;
if(!QueueEmpty(&obj->q1))
{
//需要将q1中前n-1个元素导入到q2中
while(QueueSize(&obj->q1)>1)
{
QueuePush(&obj->q2, QueueFront(&obj->q1));
QueuePop(&obj->q1);
}
ret=QueueFront(&obj->q1);
QueuePop(&obj->q1);
}
else
{
//需要将q2中前n-1个元素导入到q2中
while(QueueSize(&obj->q2)>1)
{
QueuePush(&obj->q1, QueueFront(&obj->q2));
QueuePop(&obj->q2);
}
//将最后一个元素保存起来
ret=QueueFront(&obj->q2);
//将最后一个数据删除掉
QueuePop(&obj->q2);
}
return ret;
}
//取栈顶
/** 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.2用栈实现队列
题目描述：
解题思路：
在这里以图文加解释的方式给出
程序部分：
核心代码
typedef struct {
stack s1;//模拟队尾 ，入队列
stack s2;//模拟队头，出队列
} MyQueue;
/** Initialize your data structure here. */
MyQueue* myQueueCreate() {
MyQueue* mq=(MyQueue*)malloc(sizeof(MyQueue));
if(NULL==mq)
{
return NULL;
}
StackInit(&mq->s1);
StackInit(&mq->s2);
return mq;
}
//入栈q1，模拟入队列
/** Push element x to the back of queue. */
void myQueuePush(MyQueue* obj, int x) {
StackPush(&obj->s1,x);
}
/** Removes the element from in front of queue and returns that element. */
int myQueuePop(MyQueue* obj) {
//s2模拟出队列
//如果s2是空的，将s1中的元素搬移到s2中
if(StackEmpty(&obj->s2))
{
while(!StackEmpty(&obj->s1))
{
StackPush(&obj->s2,StackTop(&obj->s1));
StackPop(&obj->s1);
}
}
int ret=StackTop(&obj->s2);
StackPop(&obj->s2);
return ret;
}
//获取队头元素
/** Get the front element. */
int myQueuePeek(MyQueue* obj) {
if(StackEmpty(&obj->s2))
{
while(!StackEmpty(&obj->s1))
{
StackPush(&obj->s2,StackTop(&obj->s1));
StackPop(&obj->s1);
}
}
return StackTop(&obj->s2);
}
/** Returns whether the queue is empty. */
bool myQueueEmpty(MyQueue* obj) {
return StackEmpty(&obj->s1)&&StackEmpty(&obj->s2);
}
void myQueueFree(MyQueue* obj) {
StackDestroy(&obj->s1);
StackDestroy(&obj->s2);
free(obj);
}
3.3循环队列
题目描述：
解题思路：
循环队列是为了解决队列假溢出的情况，使开辟的空间不被浪费。
判断循环队列是空还是满？
1.少存储一个数据
2.使用计数 count
count= =0，是为空
count= =NULL,则为满。
循环队列主要的实现：入队和出队。
入队中的实现：先判断队列是否满了，如果不满则有两种情况：
如果队尾刚好在空间的末尾则将队尾的元素放在0号下标的位置。
如果正常入队，则是将元素尾插进去，然后将尾的位置rear向后移动。
出队的实现：先判断队列是否为空，如果不为空将头的位置front向后移动，
如果front移到了最后一个位置则将front放在0的下标号。
front每移动一个，count就减少一个。
获取队尾的位置：如果rear在0号标号，则返回最后一个元素，
否则，返回rear-1；
剩余步骤的实现则较为常规。
程序部分：
核心代码
typedef struct {
int* arr;
int capacity;
int front;
int back;
int count;
} MyCircularQueue;
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* mq=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));//在堆上创建了结构体变量
if(NULL==mq)
{
return NULL;
}
mq->arr=(int*)malloc(sizeof(int)*k);
if(NULL==mq->arr)
{
return NULL;
}
mq->capacity=k;
mq->front=mq->back=mq->count=0;
return mq;
}
//判空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
return obj->count==0;
}
//队列满了
bool myCircularQueueIsFull(MyCircularQueue* obj) {
return obj->count==obj->capacity;
}
//入队
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)
{
if(myCircularQueueIsFull(obj))
{
return false;
}
//rear可能刚好在队列的末尾位置
if(obj->back == obj->capacity)
{
obj->back=0;
}
obj->arr[obj->back++]= value;
obj-> count++;
return true;
}
//出队
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
{
return false;
}
obj->front++;
if(obj->front==obj->capacity)
{
obj->front=0;
}
obj->count--;
return true;
}
//获取队列首元素
int myCircularQueueFront(MyCircularQueue* obj){
if(myCircularQueueIsEmpty(obj))
{
return -1;
}
return obj->arr[obj->front];
}
//队尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
//如果rear在下标号为0的位置
if(myCircularQueueIsEmpty(obj))
{
return -1;
}
//if(0==obj->back)
// {
// return obj->arr[obj->capacity-1];
// }
// else
//{
//return obj->arr[obj->back-1];
//}
return obj->arr[(obj->back-1+obj->capacity)%obj->capacity];
}
void myCircularQueueFree(MyCircularQueue* obj) {
free(obj->arr);
free(obj);
}
总结
将自己所学的知识进行总结，归纳，需要改进的地方还有许多，继续加油吧！！！