在vscode中配置git bash终端-CFANZ编程社区

因为害怕，所以勇敢。

一、栈的概念以及结构

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。 进行数据插入和删除操作的一端 称为栈顶 ，另一端称为 栈底。栈中的数据元素遵守后进先出 LIFO （ Last In First Out ）的原则。【后进先出】

压栈：栈的插入操作叫做进栈 / 压栈 / 入栈， 入数据在栈顶 。

出栈：栈的删除操作叫做出栈。 出数据也在栈顶 。

二、栈的实现

栈的实现，是选择数组还是链表呢？答案是：数组。单链表也可以，但是数组更好

ღ理由是：可以把数组的后面当做栈顶，前面当做栈底。插入，删除方便，但是要扩容。CPU高速缓存命中率会更高。

stack.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

typedef int STDataType;

typedef struct stack
{
	STDataType* a;
	int top;//栈顶的位置
	int capacity;//容量
}ST;

void StackInit(ST* ps);
void StackDestory(ST* ps);
//插入
void StackPush(ST* ps, STDataType x);
//删除
void StackPop(ST* ps);
//判断栈是否为空
bool StackEmpty(ST* ps);
//栈有多少个数
int StackSize(ST* ps);
//访问栈顶的数据
STDataType StackTop(ST* ps);

stack.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "stack.h"

void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
//插入
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//扩容
	if (ps->capacity == ps->top)//
	{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * (ps->capacity);//容量
		ps->a = (STDataType*)realloc(ps->a, newCapacity * sizeof(STDataType));//
		if (ps->a == NULL)
		{
			printf("realloc fail \n");
			exit(-1);
		}
		ps->capacity = newCapacity;
	}
	
	ps->a[ps->top] = x;
	ps->top++;
}
//删除
void StackPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	--ps->top;
}
//判断栈是否为空
bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;//等于0的话，就是真，不等于0的话，就是假
}
//栈有多少个数
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
//访问栈顶的数据
STDataType StackTop(ST* ps)
{
	assert(ps);
	return ps->a[ps->top - 1];
}

三、习题

3.1 选择题

1. 一个栈的初始状态为空。现将元素 1 、 2 、 3 、 4 、 5 、 A 、 B 、 C 、 D 、 E 依次入栈，然后再依次出栈，则元素出栈的顺序是（B ）。

A 12345ABCDE

B EDCBA54321

C ABCDE12345

D 54321EDCBA

2. 若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（C）

A 1,4,3,2

B 2,3,4,1

C 3,1,4,2

D 3,4,2,1

【进栈过程中可以出栈】

3.2 括号匹配问题

https://leetcode.cn/problems/valid-parentheses/

代码如下：【此代码里面不包括栈,仅仅把栈的实现的上述代码把int换成char】

bool isValid(char * s)
{
    ST st;
    StackInit(&st);
    while(*s)
    {
        if (*s == '(' || *s == '[' || *s == '{')
        {
            StackPush(&st, *s);
            s++;
        }
        else
        {
            if (StackEmpty(&st))
            {
                return false;
            }
            char top = StackTop(&st);
            StackPop(&st);
            if ((*s == ']' && top != '[') || (*s == ')' && top != '(') || (*s == '}' && top != '{'))
            {
                StackDestory(&st);
                return false;
            }
            else
            {
                s++;
            }
        }
    }
    bool ret = StackEmpty(&st);
    StackDestory(&st);
    return ret;
}

思路：用栈。遍历字符串，如果遇到左括号就入栈，如果是右括号就进行匹配，不匹配就返回false,当遍历完字符串，如果全部匹配，就返回true