数据结构学习笔记（栈、队列）整理与总结

栈

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

栈结构之顺序栈的基本介绍

概念： 栈是限定仅在表尾进行插人或删除操作的线性表。因此，对栈来说，表尾端有其特殊含义，称为栈顶，相应地，表头端称为栈底。不含元素的空表称为空栈。栈的修改是按后进先出的原则进行的，因此栈又称为后进先出的线性表，简称LIFO结构。而顺序栈就是使用顺序结构来实现栈，顺序栈的空间是连续分配的。
结构图：

结构代码描述：

定义顺序栈结构体：

// An highlighted block
//顺序栈
typedef struct SeqStack
{
   
	ElemType *base; //栈空间
	size_t    capacity;
	size_t    top; //栈顶指针
}SeqStack;

顺序栈的常用操作

**初始化顺序栈**

// An highlighted block
void SeqStackInit(SeqStack *pst, int sz)
{
   
    //设置容量的初始化大小
	pst->capacity = sz > SEQ_STACK_DEFAULT_SIZE ? sz : SEQ_STACK_DEFAULT_SIZE;
    //申请空间
	pst->base = (ElemType *)malloc(sizeof(ElemType) * pst->capacity);
	assert(pst->base != NULL);
	pst->top = 0;//栈顶的初始化指向
}

**判断栈是否满或者空**

// An highlighted block
//判断栈是否满
bool IsFull(SeqStack *pst)
{
   
	return pst->top >= pst->capacity;
}
//判断栈是否空
bool IsEmpty(SeqStack *pst)
{
   
	return pst->top == 0;
}

**入栈**

// An highlighted block
void SeqStackPush(SeqStack *pst, ElemType v)
{
   
	if(IsFull(pst))
	{
   
		printf("栈已满,%d不能入栈.\n", v);
		return;
	}
	pst->base[pst->top++] = v;//放到top所指的下标的空间，然后top再++
}

**出栈**

// An highlighted block
void SeqStackPop(SeqStack *pst)
{
   
	if(IsEmpty(pst))
	{
   
		printf("栈已空，不能出栈.\n");
		return;
	}
	pst->top--;//出栈
}

**获取栈顶元素**

// An highlighted block
ElemType SeqStackTop(SeqStack *pst)
//void SeqStackTop(SeqStack *pst, ElemType *v) //出参
{
   
	if(IsEmpty(pst))
	{
   
		printf("栈已空，没有栈顶元素.\n");
		return;
	}
	return pst->base[pst->top-1];//top-1不会更改top指针的指向，这样就不会删除指向的元素
	//*v = pst->base[pst->top-1];
}

**打印栈内所有数据**

// An highlighted block
void SeqStackShow(SeqStack *pst)
{
   
	for(int i=pst->top-1; i>=0; --i)
		printf("%d\n", pst->base[i]);
}

**顺序栈的摧毁**

// An highlighted block
void SeqStackDestroy(SeqStack *pst)
{
   
	free(pst->base);
	pst->base = NULL;
	pst->capacity = pst->top = 0;
}

栈结构之链栈的基本介绍

概念： 栈是限定仅在表尾进行插人或删除操作的线性表。因此，对栈来说，表尾端有其特殊含义，称为栈顶，相应地，表头端称为栈底。不含元素的空表称为空栈。栈的修改是按后进先出的原则进行的，因此栈又称为后进先出的线性表，简称LIFO结构。而链栈就是使用链式结构来实现栈，链栈的空间可以是不连续分配。
结构：

**代码描述：**

// An highlighted block
typedef struct LinkStackNode
{
   
	ElemType data;
	struct LinkStackNode *next;
}LinkStackNode;
typedef struct LinkStack
{
   
	LinkStackNode *head;
}LinkStack;

链栈的常用操作

**初始化**

// An highlighted block
void LinkStackInit(LinkStack *pst)
{
   
	pst->head = NULL;
}

**入栈**

// An highlighted block
void LinkStackPush(LinkStack *pst, ElemType v)
{
   
	LinkStackNode *s = (LinkStackNode*)malloc(sizeof(LinkStackNode));
	assert(s != NULL);
	s->data = v;

	s->next = pst->head;
	pst->head = s;
}

**出栈**

// An highlighted block
void LinkStackPop(LinkStack *pst)
{
   
	LinkStackNode *p;
	if(pst->head == NULL)
		return;
	p  = pst->head;
	pst->head = p->next;
	free(p);//记得释放，都是malloc出来的
}

**栈顶元素**

// An highlighted block
ElemType LinkStackTop(LinkStack *pst)
{
   
	assert(pst->head != NULL);
	return pst->head->data;
}

**显示栈内数据**

// An highlighted block
void LinkStackShow(LinkStack *pst)
{
   
	LinkStackNode *p = pst->head;
	while(p != NULL)
	{
   
		printf("%d\n", p->data);
		p = p->next;
	}
}

**摧毁栈**

// An highlighted block
void LinkStackDestroy(