栈|数据结构

栈

概念

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

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

结构设计

结构也可以使用链表结构，还有顺序表结构。链表结构实现在栈顶取决上，可以考虑链表结构的头删头插优势。链表头删头插相较于顺序表在时间上效率高链表就是链表头部插入删除O(1)，但是数据存储空间不连续。顺序表在尾插时间复杂度O(1),但是数据存储在物理空间上是连续的。栈在实现栈可以选择较为连续空间作为栈结构。实现时就最优解。

对于栈比较常用接口初始化、压栈、出栈、销毁……

栈实现

结构定义

typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top; // 栈顶
	int _capacity; // 容量
}Stack;

这里实现结构定义虽然和顺序表大同小异，但是实现功能各有千秋。对于栈初始化理解是，如果使用结构体定义就可以在初始化时少开辟一个空间（结构体）。只需要开辟空间数组空间大小。在释放空间时可以少调用一次释放函数。

void StackInit(Stack* ps)
{
	STDataType* new = (STDataType*)malloc(10*sizeof(STDataType));
	if (new == NULL)
	{
		perror("malloc fail");
	}
	ps->_a = new;
	ps->_capacity = 10;
	ps->_top = 0;//相当于顺序表size。有效个数
}

在初始化时比较坑就是对于top赋值时。如果直接赋值0.就是栈顶元素下标的下一个。而赋值为-1.就是栈顶元素的下标。
其余接口函数实现时

// 销毁栈
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = ps->_top = 0;
}



// 入栈
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->_a, sizeof(STDataType) * 2 * ps->_capacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
		}
		ps->_a = tmp;
		ps->_capacity *= 2;
	}
	ps->_a[ps->_top] = data;//数据入栈
	ps->_top++;
}

// 出栈
void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->_top > 0);

	ps->_a[ps->_top--];
	/*ps->_top--;*/
}
// 获取栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->_top > 0);

	return ps->_a[ps->_top - 1];
}
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);

	return ps->_top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	if (ps->_a == NULL)
	{
		return 1;
	}
	return 0;
}

小试牛刀

括号匹配

这里可以使用栈特性LIFO左括号压栈，右括号出栈栈顶元素。

typedef char 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 
bool StackEmpty(Stack* ps);
// 销毁栈
void StackDestroy(Stack* ps);


// 初始化栈
void StackInit(Stack* ps)
{
	STDataType* new = (STDataType*)malloc(10*sizeof(STDataType));
	if (new == NULL)
	{
		perror("malloc fail");
	}
	ps->_a = new;
	ps->_capacity = 10;
	ps->_top = 0;//相当于顺序表size。有效个数
}

// 销毁栈
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = ps->_top = 0;
}



// 入栈
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->_a, sizeof(STDataType) * 2 * ps->_capacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
		}
		ps->_a = tmp;
		ps->_capacity *= 2;
	}
	ps->_a[ps->_top] = data;//数据入栈
	ps->_top++;
}

// 出栈
void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->_top > 0);

	ps->_a[ps->_top--];
	/*ps->_top--;*/
}
// 获取栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->_top > 0);

	return ps->_a[ps->_top - 1];
}
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);

	return ps->_top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* ps)
{
	assert(ps);
	
	return ps->_top==0;
}


bool isValid(char * s){
    Stack st;
    StackInit(&st);
    while(*s)
    {
        if(*s=='('||*s=='{'||*s=='[')
        {
            StackPush(&st,*s);
            s++;
        }
        else
        {//没有左括号
            if(StackEmpty(&st))
            {
                return false;
            }
            int top=StackTop(&st);
            StackPop(&st);
			//不匹配
            if((top=='['&&*s!=']')||(top=='{'&&*s!='}')||(top=='('&&*s!=')'))
			{
				return false;
			}
			//匹配，继续
			else{
				s++;
			}
        }
    }
    int ret=StackEmpty(&st);
    StackDestroy(&st);
    return ret;
}