栈的介绍及面试题代码（括号匹配问题）

1：栈

1.1栈的概念及结构

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

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

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

——后进先出    

 1.2：栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的 代价比较小。

数组实现：

链表实现：

 

1.3数组实现代码：

主要实现以下功能

void StackInit(Stack *ps);//初始化
void StackPush(Stack *ps, SDataType data);//入栈
void StackPop(Stack *ps);//出栈
SDataType StackTop(Stack *ps);//获取栈的元素
void StackSize(Stack *ps);//大小
int StackEmpty(Stack *ps);//判空
void StackDestroy(Stack *ps);//销毁
void CheckCapacity(static *ps);//检查容量
void StackShow(Stack* ps);//打印

1：头文件：Stack.h

#ifndef _STACK_H_
#define _STACK_H_

#define	_CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int SDataType;

typedef struct Stack
{
	SDataType *_array;
	int _capacity;
	int _size_;//表示栈中的有效个数 代表栈顶
}Stack;

void StackInit(Stack *ps);//初始化
void StackPush(Stack *ps, SDataType data);//入栈
void StackPop(Stack *ps);//出栈
SDataType StackTop(Stack *ps);//获取栈的元素
void StackSize(Stack *ps);//大小
int StackEmpty(Stack *ps);//判空
void StackDestroy(Stack *ps);//销毁
void CheckCapacity(static *ps);//检查容量
void StackShow(Stack* ps);//打印

#endif // !_STACK_H_

2:Stack.c

#include"Stack.h"

void StackInit(Stack *ps)//初始化
{
	assert(ps);
	ps->_array = (SDataType*)malloc(sizeof(SDataType) * 3);
	if (NULL == ps->_capacity)
	{
		assert(0);
		return;
	}
	ps->_capacity = 3;
	ps->_size_ = 0;
}

void CheckCapacity(Stack *ps)//检查容量并扩容
{
	assert(ps); 
	if (((ps->_capacity) - (ps->_size_ ))<= 2)
	{
		SDataType* p = NULL;
		ps->_capacity *= 2;
		p = (SDataType*)realloc(ps->_array,sizeof(SDataType)*(ps->_capacity));//realloc如果开辟空间失败会返回空，所以不能直接扩容
		if (NULL == p)
		{
			assert(0);
			return;
		}
		ps->_array = p;
	}
}

void StackPush(Stack *ps, SDataType data)//入栈
{
	assert(ps);
	CheckCapacity(ps);
	ps->_array[ps->_size_++] = data;
}

void StackPop(Stack *ps)//出栈
{
	assert(ps);
	if (StackEmpty(ps))
	{
		return;
	}
	ps->_size_--;
}

SDataType StackTop(Stack *ps)//获取栈顶的元素
{
	assert(ps);
	return ps->_array[ps->_size_ - 1];
}

void StackSize(Stack *ps)//大小
{
	assert(ps);
	return ps->_size_;
}

int StackEmpty(Stack *ps)//判空
{
	assert(ps);
	return 0 == ps->_size_;
}

void StackDestroy(Stack *ps)//销毁
{
	assert(ps);
	if (ps->_array)
	{
		ps->_capacity = 0;
		ps->_size_ = 0;
		free(ps->_array);
	}
}

void StackShow(Stack* ps)//打印
{
	assert(ps);
	int tmp = 0;
	while (tmp< ps->_size_)
	{
		printf("%-3d", ps->_array[tmp]);
		tmp++;
	}
	printf("\n");
}

3:测试test.c

#include"Stack.h"

void Funs()
{
	Stack s;
	StackInit(&s);
	StackPush(&s, 1);//入栈
	StackPush(&s, 2);
	StackPush(&s, 3);
	StackShow(&s);//打印
	StackPush(&s, 4);
	StackPush(&s, 5);
	StackShow(&s);//打印
	StackPop(&s);//出栈
	StackPop(&s);
	StackShow(&s);
	SDataType k = StackTop(&s);//获取栈顶元素
	printf("top = %d\n", k);
	StackPush(&s, 4);
	k = StackTop(&s);
	printf("top = %d\n", k);
	StackDestroy(&s);
}
int main()
{
	Funs();
	system("pause");
	return 0;
}

输出结果：

2：栈的面试题

2.1：题目描述：

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

2.2：代码

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef char DataType;

typedef struct Stack
{
  DataType *array;
  size_t capacity;
  size_t size;
}Stack;

void StackInit(Stack *ps)//初始化
{
  assert(ps);
  ps->array = (DataType*)malloc(sizeof(DataType)*3);
  if(NULL == ps->array)
  {
    assert(0);
    return;
  }
  ps->capacity = 3;
  ps->size = 0;
}

void StackCapacity(Stack *ps)//检查容量并扩容
{
  assert(ps);
  if(ps->capacity == ps->size)
  {
    ps->capacity *= 2;
    DataType *p = (DataType*)realloc(ps->array,(ps->capacity)*sizeof(DataType));
    if(NULL == p)
    {
      assert(0);
      return;
    }
    ps->array = p;
  }
}

void StackPushBack(Stack *ps, DataType data)//入栈
{
  assert(ps);
  StackCapacity(ps);
  ps->array[ps->size++] = data;
}

void StackPopBack(Stack *ps)//出栈
{
  assert(ps);
  ps->size--;
}

void StackShow(Stack *ps)//打印
{
  assert(ps);
  size_t count = 0;
  while(count < ps->size)
  {
    printf("%-3c",ps->array[count++]);
  }
  printf("\n");
}

DataType StackTop(Stack *ps)//获得栈顶
{
  return ps->array[(ps->size)-1];
}

void StackDestary(Stack *ps)//摧毁
{
  assert(ps);
  if(ps->array)
  {
    free(ps->array);
    ps->capacity = 0;
    ps->size = 0;
  }
}

int main()
{
  Stack p;
  StackInit(&p);
  DataType s[5] = "{(]}";
  int i = 0;
  while(i<4)
  {
    if(s[i] == '{' || s[i] == '(' || s[i] == '[' )
    {
      StackPushBack(&p, s[i]);
    }
    else 
    {
      if(p.size > 0)
      {
        DataType a = StackTop(&p);
        if(s[i] == ')' && a == '(')
        {}
        else if(s[i] == '}' && a == '{')
        {}
        else if(s[i] == ']' && a == '[')
        {}
        else 
        {
          printf("error\n");
          return 0;
        }
        StackPopBack(&p);
      }
    }
    i++;
  }
  if(p.size == 0)
  {
    printf("right\n");
    return 0;
  }
  printf("error\n");
  return 0;
}