栈和队列的概念及实现

一、栈

1、栈的概念及结构

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

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

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

 2、栈的实现

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

 下面实现动态增长的栈

#define MAX_SIZE 3
#define INC_SIZE 10

typedef int DataType;

typedef struct Stack
{
	DataType* arr;
	int capacity;    //容量
	int size;        //有效元素个数
}Stack;

//扩容函数
static void _IncCapacity(Stack* s)
{
	assert(s != NULL);
	//申请新空间
	DataType* tmp = (DataType*)malloc(sizeof(DataType) * (s->capacity + INC_SIZE));
	if (tmp == NULL)
	{
		printf("IncCapacity:malloc失败\n");
		exit(0);
	}
	//将旧空间的值拷贝到新空间中
	memcpy(tmp, s->arr, sizeof(DataType) * s->size);
	//释放旧空间，并指向新空间
	free(s->arr);
	s->arr = tmp;
	s->capacity += INC_SIZE;
}

//初始化栈
void StackInit(Stack* s)
{
	assert(s != NULL);
	s->arr = (DataType*)malloc(sizeof(DataType) * MAX_SIZE);
	if (s->arr == NULL)
	{
		printf("StackInit:malloc失败\n");
		exit(0);
	}
	s->capacity = MAX_SIZE;
	s->size = 0;
}
//入栈
void StackPush(Stack* s, DataType data)
{
	assert(s != NULL);
	if (s->size == s->capacity)
		_IncCapacity(s);
	s->arr[s->size] = data;
	s->size++;
}
//出栈
void StackPop(Stack* s)
{
	assert(s != NULL);
	if (StackEmpty(s))
		return;
	s->size--;
}
//获取栈顶元素
DataType StackGetTop(Stack* s)
{
	assert(s != NULL);
	assert(s->size != 0);
	return s->arr[s->size - 1];
}
//获取栈内有效元素个数
int StackSize(Stack* s)
{
	assert(s != NULL);
	return s->size;
}
//检测栈是否为空，为空返回非0，不为空返回0
int StackEmpty(Stack* s)
{
	assert(s != NULL);
	return s->size == 0;
}
//销毁栈
void StackDestroy(Stack* s)
{
	assert(s != NULL);
	free(s->arr);
	s->arr = NULL;
	s->capacity = 0;
	s->size = 0;
}
//打印栈
void StackPrint(Stack* s)
{
	assert(s != NULL);
	for (int i = 0; i < s->size; ++i)
		printf("%d ", s->arr[i]);
	printf("\n");
}

二、队列

1、队列的概念及结构

队列是只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表。队列具有先进先出FIFO(First In First Out)的原则。

        入队：进行插入操作的一端称为队尾

        出队：进行删除操作的一端称为队头

 2、队列的实现

队列也可以用数组或链表的结构实现，使用链表的结构更优一些，因为如果使用数组的结构，出队列在数据头上出数据，效率会比较低。

 代码实现

typedef int DataType;
//链式结构:表示队列
typedef struct QNode
{
	DataType data;
	struct QNode* next;
}QNode;
//队列结构
typedef struct Queue
{
	QNode* front;
	QNode* back;
}Queue;

//申请节点
static QNode* _BuyQNode(DataType data)
{
	QNode* newNode = (QNode*)malloc(sizeof(QNode));
	if (newNode == NULL)
	{
		printf("_BuyQNode:malloc失败\n");
		exit(0);
	}
	newNode->data = data;
	newNode->next = NULL;
	return newNode;
}

//初始化队列
void QueueInit(Queue* q)
{
	assert(q != NULL);
	q->front = NULL;
	q->back = NULL;
}
//入队
void QueuePush(Queue* q, DataType data)
{
	assert(q != NULL);
	QNode* newNode = _BuyQNode(data);
	if (QueueEmpty(q))
	{
		//队列为空
		q->front = newNode;
		q->back = newNode;
	}
	else
	{
		//队列不为空
		q->back->next = newNode;
		q->back = newNode;
	}
}
//出队
void QueuePop(Queue* q)
{
	assert(q != NULL);
	if (QueueEmpty(q))
	{
		//队为空
		return;
	}
	else
	{
		QNode* delNode = q->front;
		q->front = q->front->next;
		free(delNode);
		//队列只有一个元素时
		if (q->front == NULL)
			q->back = NULL;
	}
}
//获取队列头部元素
DataType QueueGetFront(Queue* q)
{
	assert(q != NULL);
	assert(q->front != NULL);
	return q->front->data;
}
//获取队列尾部元素
DataType QueueGetBack(Queue* q)
{
	assert(q != NULL);
	assert(q->back != NULL);
	return q->back->data;
}
//获取队列有效元素个数
int QueueSize(Queue* q)
{
	assert(q != NULL);
	QNode* pcur = q->front;
	int cnt = 0;
	while (pcur != NULL)
	{
		cnt++;
		pcur = pcur->next;
	}
	return cnt;
}
//检测队列是否为空。为空返回非0，不为空返回0
int QueueEmpty(Queue* q)
{
	assert(q != NULL);
	return q->front == NULL;
}
//销毁队列
void QueueDestroy(Queue* q)
{
	assert(q != NULL);
	QNode* pcur = q->front;
	while (pcur != NULL)
	{
		q->front = q->front->next;
		free(pcur);
		pcur = q->front;
	}
}
//打印队列
void QueuePrint(Queue* q)
{
	assert(q != NULL);
	QNode* pcur = q->front;
	while (pcur != NULL)
	{
		printf("%d ", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}