C语言：栈和队列+leetcode232、leetcode225：队实现栈、栈实现队列、leetcode20括号匹配
1. 栈
- 前言：一般的栈的内核是连续的一片空间，即：数组，那么是如何实现的FILO呢？通过top指针，每次pop只能出top位置的值。此外，栈的实现根据top初始化时处于-1和0位置稍有差异。
- 头文件
#pragma once
#include- 头文件实现
#include"ds_2_stack.h"
// 栈的初始化：做栈数组大小初始化，以及指针在-1还是0，-1和0的区别是 插入和删除时，先动针还是先动数
void StackInit(Stack* ps)
{
// 栈不可以为空
assert(ps);
ps->_a = NULL;
ps->_top = ps->_capacity = 0;
}
void StackPush(Stack* ps, STDataType data)
{
assert(ps);
// 因为初始 top和capacity相等所以插入要扩容
if (ps->_top == ps->_capacity)
{
int newCapacity = ps->_capacity ==0?4:ps->_capacity*2;
// realloc：(原始数组名，新大小)
STDataType* tmp = (STDataType*)realloc(ps->_a, newCapacity*sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
exit(-1);
}
ps->_a = tmp;
// 容量是多少
ps->_capacity = newCapacity;
}
// 直接给数组值：因top初始为0，0可放，所以先放再加
ps->_a[ps->_top] = data;
ps->_top++;
}
void StackPop(Stack* ps)
{
assert(ps);
// asset中放希望，希望栈不空，所以是 !empty
assert(!StackEmpty(ps));
ps->_top--;
}
STDataType StackTop(Stack* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->_a[ps->_top-1]; // 在前一个位置
}
bool StackEmpty(Stack* ps)
{
assert(ps);
// top在0为空
return ps->_top == 0;
}
int StackSize(Stack* ps)
{
assert(ps);
return ps->_top;
}
void StackDestroy(Stack* ps)
{
assert(ps);
free(ps->_a); // 释放
ps->_a = NULL; //防止野指针
ps->_top = ps->_capacity = 0; // top归0 容量清0
}
// 判断括号匹配
- main():
#define _CRT_SECURE_NO_WARNINGS
#include"ds_2_stack.h"
void TestStack()
{
Stack st;
StackInit(&st); // 一级指针，所以传入地址
/*
数据结构如果直接访问，可能会出错，因为你不知道内部实现，比如这里的top，初始化不确定是0或1
if (st._top > 0)
{
;
}*/
StackPush(&st, 1);
StackPush(&st, 2);
StackPush(&st, 3);
StackPush(&st, 4);
int cur;
while (!StackEmpty(&st))
{
cur = StackTop(&st);
StackPop(&st);
printf("出去的是%d \n", cur);
}
StackDestroy(&st);
}
int main()
{
TestStack();
return 0;
}
- 效果
2.1 队列（单项链表节点队列）
注意：
该队列每个元素存在链表节点中，求size时，直接遍历一遍，也可以直接
#include注意点：（本人犯过的错误）：
- pop()：在做pop时，我使用了如下画了X的代码：陷入的思维错误是使用了Empty判断当前删除掉的是不是最后一个元素，而empty的实现方法是：
return q->_front == q->_rear && q->_rear == NULL;
它判断当前的front和rear是不是相等且其中之一不存在，而我利用free删除最后一个元素之后，还没有将rear和front置NULL，就不能调用这个函数，修改写法可以按照下面的写法或者把判断条件变成：if(!q->front):即队头不存在，再做置NULL，如下标X的方法不会进去if内部。所以，在做数据结构的函数实现时候，调用某些已经实现了的方法，需要考虑是否当前函数的操作会影响你调用的函数，不可贸然使用。
- empty()：我原始的代码是如下这个鸟样：明显错了，缺少了判断rear或front是否有一方为NULL。
而且优雅的写法是：直接返回bool值
return q->_front == q->_rear && q->_rear == NULL;
2.2队列(双向循环队列)
-
- 特点：与单向队列不同，为了区分队列的空和满判断情况，往往比实际存储数量多开辟一个空间，即队尾永远指向空。
-
- 常用判断式：其中N是队列元素个数，而N代表队列总空间(比元素个数大1) 。默认下标从0开始
队空：(rear == front)
队满：(rear+1)%(n+1) == front
队元素个数：(rear - front + N) % N 【先判断队列是不是满，不满才用此公式】
- 常用判断式：其中N是队列元素个数，而N代表队列总空间(比元素个数大1) 。默认下标从0开始
-
- 实现：
核心：使用数组和数组下标。
- 实现：
1.队列结构体定义：
循环数组是怎样循环起来的：我们定义结构体，内部使用动态数组a开辟固定长度。循环队列大小常常固定不变。此外，连接起来是因为我们在做入队操作和出队操作时，通过+N再加上对N取模，与实际空间位置无关，它之所以循环，是因为队列等数据结构具逻辑性。即：人为赋予逻辑关系。
typedef struct {
int front;
int rear;
int* a;// 用数组来开辟空间
} MyCircularQueue;
2. 实现
// 内核是数组
typedef struct {
int front;
int rear;
int* a; // 用数组来开辟空间
int N; // 空间（比size大1）
} MyCircularQueue;
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* obj = (struct MyCircularQueue*)malloc(sizeof(MyCircularQueue));
// k是队列元素个数 真实空间要大1
obj->a = (int*)malloc(sizeof(int)*(k+1));
obj->front = 0;
obj->rear = 0;
obj->N = k+1; // 空间
return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
return obj->front == obj->rear;
}
bool myCircularQueueIsFull(MyCircularQueue* obj) {
return (obj->rear + 1)%(obj->N) == obj->front;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
// 没有满，才能插
if (myCircularQueueIsFull(obj))
{
return false;
}
// 没满就放了++
else
{
obj->a[obj->rear] = value;
obj->rear++;
// 防止obj在最后超过一圈
obj->rear %= obj->N;
return true;
}
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
if (myCircularQueueIsEmpty(obj))
return false;
else
{
// 数组删数据不需要清
obj->front++;
obj->front %= obj->N;
return true;
}
}
int myCircularQueueFront(MyCircularQueue* obj) {
// 空返回-1
if (myCircularQueueIsEmpty(obj))
{
return -1;
}
else
{
return obj->a[obj->front];
}
}
// ** 4 第2点： 注意巧妙的写法 ***
int myCircularQueueRear(MyCircularQueue* obj) {
if (myCircularQueueIsEmpty(obj))
{
return -1;
}
else
{
// 取队尾 应是减1位，但是可能rear在0位置
// 只能判断back是不是0
return obj->a[(obj->rear - 1 + obj->N) % obj->N];
}
}
// 注意这里有两个malloc，所以就malloc两次
void myCircularQueueFree(MyCircularQueue* obj) {
free(obj->a);
free(obj);
return ;
}
4. 上面实现中的注意点
- 不论是入队出队，涉及指针的++，但是由于循环需要回到0，所以一定记得做%N【N是队列空间大小，是n+1】
- 求尾rear元素时，返回的是数组a的rear-1+n%n。因为队列预留一个空间的原因，最后一个数据存在rear前一个位置，而当rear==0时，-1是负数，所以我们应该用+n模n，使得结果回到末位。
- 队列的free：循环队列内核是动态数组，使用了malloc，所以最后需要free内部的数组空间，但是本身结构体也使用了malloc，所以还需要队本身使用free。
3. leetcode232 栈实现队列
leetcode232
typedef struct Stack
{
int* stk; // 栈内核也是数组
int top; // 栈大小也就是指针
int stkCapacity; //栈的容量
// 奇怪它不用指针吗
}Stack;
// 栈的大小
// param：输入栈大小
Stack* stackCreate(int capacity)
{
// 用malloc 注意：栈和队列，均要用两次malloc，结构体本身和内部的stk
Stack* ret = (struct Stack*)malloc(sizeof(Stack));
ret->stk = (int*)malloc(sizeof(int)*capacity);
ret->stkCapacity = capacity;
ret->top = 0; // 让起始位置为0 所以先存再++
return ret;
}
// 这里先不做满的判断
void stackPush(Stack* st, int val) {
// 容量：top从0开始
printf("给位置%d存值\n", st->top);
st->stk[st->top] = val;
printf("push栈时接收到的val：%d\n", val);
st->top++;
}
void stackPop(Stack* st)
{
// 因为是数组，直接减
st->top--;
}
int stackTop(Stack* st)
{
return st->stk[st->top-1];
}
bool stackEmpty(Stack* st)
{
return st->top==0;
}
void stackFree(Stack* st)
{
// 这里我比leetcode答案多写了一行
free(st->stk);
free(st);
}
// 队列使用栈实现：需要的是出的栈的指针和入的栈的指针
typedef struct {
Stack* ins; // 接收放
Stack* outs; // 发送放
} MyQueue;
MyQueue* myQueueCreate() {
MyQueue* ret = (MyQueue*)malloc(sizeof(MyQueue));
ret->ins = stackCreate(100);
ret->outs = stackCreate(100);
return ret;
}
// 1. 只要栈的发送方有，就都给栈接收方
void out2to(MyQueue* que)
{
// 只要发送栈不空
printf("这里是out2in\n");
while (!stackEmpty(que->outs))
{
int val = stackTop(que->outs);
stackPop(que->outs);
printf("out2in调用了pop\n");
printf("out2in时，对ins做push\n");
stackPush(que->ins, val);
}
}
void myQueuePush(MyQueue* obj, int x) {
// 入队，给ins->val
printf("que_push\n");
printf("que的push应该先给outs,下面是outs在做push\n");
stackPush(obj->outs, x);
printf("outs_push完了\n");
}
// 队列做出队，我们要出接收方，而接收方如果没有就不能出队，所以先做发送,如果有，就直接发送
int myQueuePop(MyQueue* obj) {
// 出队应该出接收方
if(stackEmpty(obj->ins))
{
out2to(obj);
}
// 判断完是否空，下面的是一定要做的操作
int val;
val = stackTop(obj->ins);
printf("这里是que的pop，下面调用了ins做pop\n");
stackPop(obj->ins);
return val;
}
// 队列的队首：如果ins没有了，就直接做发送操作
// 最后必须做的肯定是返回top值
int myQueuePeek(MyQueue* obj) {
if (stackEmpty(obj->ins))
{
printf("peek调用了out2in\n");
out2to(obj);
}
return stackTop(obj->ins);
}
bool myQueueEmpty(MyQueue* obj) {
return stackEmpty(obj->ins)&&stackEmpty(obj->outs);
}
void myQueueFree(MyQueue* obj) {
stackFree(obj->outs);
stackFree(obj->ins);
}
收获：1. empty判断
2. malloc，总结：
3. 得不到某些值，或者某些值特别大：是因为我压根没给值，或者我st->top = 。应该是st->a[st->top] = val;
4. leetcode 225:队列实现栈
leetcode225
我今天使用单链表实现一次试试。
方法(一) ： C++版本：使用STL库，该库中的队列是循环队列。
思路(一)：
- 因为栈的顺序是FILO，该栈使用一个队列可以巧妙实现的办法是：每次给栈中push，实际是对队列push，但对队列push时，假设内部是321，我们push4到队尾得到：3214，然后做1~size-1的出队和入队，最终得到：4321。用一个队列就可得到栈顺序。
- 该题让实现队列的push、pop、empty、top，下面是详细思路：
push(x)：先push(x)到内核的队尾，然后把该元素之前的元素先利用que做pop，再push：范围是1~que.size-1，【这里的que->size是元素个数】
pop：pop就是直接对队列做pop，但是先取出top，,因为每次push保证了队首元素是出栈想要的第一个元素。
empty：队列若空，则栈也是空的。
top：top就是队列的第一个，取front即可。
做法：1. 队栈做push，把x插到队尾。利用循环，pop一下push一下，至队尾之前所有元素。
class MyStack {
public:
// 使用队自带循环队列的库
queue<int> que;
MyStack() {
}
void push(int x) {
// 放元素，先入队，此时新元素在队尾
que.push(x);
// 先push后，做1~size-1次后移
for(int i = 1; i <que.size();i++)
{
que.push(que.front());
que.pop();
}
}
int pop() {
// pop返回队首元素
int t = que.front();
que.pop();
return t;
}
int top() {
// 要栈首，返回队首即可
return que.front();
}
bool empty() {
// 队空即栈空
return que.empty();
}
};
/**
* Your MyStack object will be instantiated and called as such:
* MyStack* obj = new MyStack();
* obj->push(x);
* int param_2 = obj->pop();
* int param_3 = obj->top();
* bool param_4 = obj->empty();
*/
方法(二)：用两个队列（单链表）去实现栈。
具体过程：
一般情况下，两个队列永远是一个有值，一个无值。
push：
- 两个队列都空，任意找一个队列push。
- 用一个队列空，一个队列不空，就给不空的做push。
pop： - 做pop时，先把有值的一方的n-1个值，全部push到空的队列，再pop 删去n-1个，原来有值的队列就剩下了一个值，此时pop得到的值就是栈想要的栈顶。
top
做top时，直接返回不空的队列的尾back
empty：
empty(q1)&&empty(q2)
#include“方法（三）”：错误的，不可取， 利用C语言自写单向队列：只使用一个队列时，单项队列的头和尾，一直在变化，这个题会非常复杂。
5. 栈的应用：括号匹配 leetcode20
- 思路：
利用栈后进先出的结构，每次进去右括号，看当前栈顶是否是其对应的左括号 - 算法：
遇到左括号就入栈
遇到右括号就比较是不是跟当前字符对应的左括号，如果不对应，就返回false
其中，注意
a. 右括号多的情况：else中判断栈是否已空。
b. 左括号多的情况：最后while出去可能剩余左括号，做empty判断 - 注意：
遍历过程中：使用的是*s，且栈的datatype默认是int，虽然s是字符，但是push时因为push的接收类型是int，所以会转为int，取出比较也会转为char，这些不必在意。
代码：
typedef int STDataType;
typedef struct Stack
{
STDataType* _a; // 用指针类型 用数组 这是动态的 且栈一般定义的是动态的
int _top; // 栈顶
int _capacity; // 容量 ：最多放多少
}Stack;
// 初始化栈
void StackInit(Stack* ps);
// 入栈
void StackPush(Stack* ps, STDataType data);
// 出栈
void StackPop(Stack* ps);
// 获取栈顶元素
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps);
// 销毁栈
void StackDestroy(Stack* ps);
// 栈的初始化：做栈数组大小初始化，以及指针在-1还是0，-1和0的区别是 插入和删除时，先动针还是先动数
void StackInit(Stack* ps)
{
// 栈不可以为空
assert(ps);
ps->_a = NULL;
ps->_top = ps->_capacity = 0;
}
void StackPush(Stack* ps, STDataType data)
{
assert(ps);
// 因为初始 top和capacity相等所以插入要扩容
if (ps->_top == ps->_capacity)
{
int newCapacity = ps->_capacity ==0?4:ps->_capacity*2;
// realloc：(原始数组名，新大小)
STDataType* tmp = (STDataType*)realloc(ps->_a, newCapacity*sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
exit(-1);
}
ps->_a = tmp;
// 容量是多少
ps->_capacity = newCapacity;
}
// 直接给数组值：因top初始为0，0可放，所以先放再加
ps->_a[ps->_top] = data;
ps->_top++;
}
void StackPop(Stack* ps)
{
assert(ps);
// asset中放希望，希望栈不空，所以是 !empty
assert(!StackEmpty(ps));
ps->_top--;
}
STDataType StackTop(Stack* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->_a[ps->_top-1]; // 在前一个位置
}
int StackEmpty(Stack* ps)
{
assert(ps);
// top在0为空
return ps->_top == 0;
}
int StackSize(Stack* ps)
{
assert(ps);
return ps->_top;
}
void StackDestroy(Stack* ps)
{
assert(ps);
free(ps->_a); // 释放
ps->_a = NULL; //防止野指针
ps->_top = ps->_capacity = 0; // top归0 容量清0
}
bool isValid(char* s) {
struct Stack* st;
st = (Stack*)malloc(sizeof(Stack));;
StackInit(st);
while (*s)
{
if (*s == '(' || *s == '[' || *s == '{')
{
StackPush(st, *s);
}
else
{
// 右括号多的情况：即栈内空了，当前是右括号
if(StackEmpty(st))
{
return false;
}
char t = StackTop(st);
if (*s == ')')
{
if (t != '(')
{
return false;
}
}
else if (*s == ']')
{
if (t != '[')
{
return false;
}
}
else if (*s == '}')
{
if (t != '{')
{
return false;
}
}
StackPop(st);
}
s++;
}
// 最后栈不空，肯定里面是因为有左括号，所以就直接返回错
if (!StackEmpty(st))
{
return false;
}
return true;
}