数据结构：栈和队列

在学习顺序表和链表之后，我们进行学习栈和队列

那么首先学习栈的定义:栈是一种特殊的线性表，其只允许固定的一端进行插入和删除操作，进行插入和删除操作的一端称为栈顶，而另一端称为栈底。栈的数据遵循后进先出；

压栈：栈的插入操作称为压栈、入栈、进栈数据在栈顶

出栈：栈的删除操作称为出栈，出数据在栈顶

那么我们接下来进行栈的实现，在实现栈的这个结构时可以使用数组和链表实现，相比之下数组实现更优，通常入栈和出栈都在数组尾进行实现。同样定长数组和动态开辟的数组都是可以的，但是动态开辟的数组更有利于使用。

首先时对栈结构的定义

//静态的栈结构
typedef int STDataType;
#define N 10
typedef struct Stack
{
    STDataType a[N];
	int top; // 栈顶
}Stack;


// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;		// 栈顶
	int capacity;  // 容量 
}Stack;

接下来我们以动态增长的数组来进行栈的实现

一、初始化

// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);
	ps->a = (STDataType*)malloc(sizeof(STDataType) * N);
	if (ps->a == NULL)
	{
		perror("Stack::malloc");
	}
	ps->capacity = N;
	ps->top = 0;//top表示当前栈顶元素

}

二、增删查改

//判断栈是否是满的,并对其扩容
void StackCheek(Stack* ps)
{
	if (ps->capacity-1 == ps->top)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("StackCheek::realloc");
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
}

// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	StackCheek(ps);

	ps->a[ps->top] = data;
	ps->top++;

}

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

// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	return ps->a[ps->top];
}

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

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

// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	if (!StackEmpty(ps))
	{
		free(ps->a);
		ps->capacity = ps->top = 0;
	}
}

//打印
void StackPrint(const Stack* ps)
{
	assert(ps);
	for (int i = 0; i < ps->top; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
int main()
{
	Stack ps;
	StackInit(&ps);
	StackPush(&ps, 1);
	StackPush(&ps, 2);
	StackPush(&ps, 3);
	StackPush(&ps, 4);
	StackPush(&ps, 5);

	StackPrint(&ps);

	StackPop(&ps);
	StackPop(&ps);
	StackPop(&ps);
	StackPop(&ps);
	StackPop(&ps);

	StackPrint(&ps);

	int n=StackSize(&ps);
	printf("%d ", n);
	StackDestroy(&ps);
	return 0;
}

栈在使用的时候一定要谨记栈是后进先出的结构

在学习完栈之后我们该学习下一结构——队列

定义：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表

        数据是先进先出；

        进行插入操作的是队尾；进行出队列操作的是对头；

一、对队列结构进行定义

///链式结构:表示队列
typedef int QDataType;
typedef struct QlistNode
{
	struct QlistNode* next;
	QDataType data;
}QNode;

//队列结构
typedef struct Queue
{
	QNode* front;
	QNode* rear;
}Queue;

二、增删查改 

//队列实现，同样可以使用数组和链表两种结构，但是链表的结构更优一点
//相比数组，元素出现在头部对链表来说更好解决


void QueueInit(Queue* p)
{
	assert(p);
	//创建第一个节点为空
	p->rear = p->front=NULL;
}

//队尾入队列
void QueuePush(Queue*p,QDataType data)
{
	assert(p);
	//尾插
	QNode* newNode = (QNode*)malloc(sizeof(QNode));
	if (newNode == NULL)
	{
		perror("QueuePush::malloc");
		return;
	}
	newNode->data = data;
	newNode->next = NULL;

	//分情况讨论，如果队头为空，则直接指向。
	if (p->front == NULL)
	{
		p->rear = p->front = newNode;
	}
	p->rear->next= newNode;
	p->rear = p->rear->next;
}

//队头出队列
void QueuePop(Queue* p)
{
	assert(p);
	if (p->front)
	{
		//当队列内有节点的情况下
		QNode* tmp = p->front->next;
		free(p->front);
		p->front = tmp;
	}
}

// 获取队列头部元素 
QDataType QueueFront(Queue* p)
{
	assert(p);
	if (p->front == NULL)//当队列为空时
	{
		printf("啥也没有\n");
		return ;
	}
	return p->front->data;
}

// 获取队列队尾元素 
QDataType QueueBack(Queue* p)
{
	assert(p);
	if (p->rear == NULL)
	{
		printf("啥也没有\n");
		return;
	}
	return p->rear->data;
}


// 获取队列中有效元素个数 
int QueueSize(Queue* p)
{
	assert(p);
	int count = 0;
	QNode* run = p->front;
	while (run)
	{
		count++;
		run = run->next;
	}
	return count;
}

// 检测队列是否为空，如果为空返回非0结果，如果非空返回0 
int QueueEmpty(Queue* p)
{
	assert(p);
	if (QueueSize(p))//当大小为0的时候
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

// 销毁队列 
void QueueDestroy(Queue* p)
{
	assert(p);
	//头删
	while (p->front != NULL)
	{
		QueuePop(p);
	}
}

void QueueTest()
{
	Queue p;
	QueueInit(&p);

	QueuePush(&p, 1);
	QueuePush(&p, 2);
	QueuePush(&p, 3);
	QueuePush(&p, 4);

	while (QueueEmpty(&p))
	{
		printf("front: %d\n",QueueFront(&p));
		QueuePop(&p);
	}
}