栈和队列的实现【C语言】

（1）栈

1.结构体的构造

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int capacity;
	int top;		//栈顶元素,初始为0，表示栈顶元素的下一个位置的坐标，初始为-1 表示栈顶元素
}ST;

2.初始化

//初始化
void StackInit(ST* ps)
{
	assert(ps);
	//ps->a = NULL;
	//ps->top = 0;
	//ps->capacity = 0;
	
//给结构体的变量a 开辟大小为STDataType的新空间
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	ps->top = -1; //top为-1时指向栈顶元素，为0时指向栈顶元素的下一个
	//将原capacity赋新大小
	ps->capacity = 4;
}

3.销毁

//销毁
void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);//释放（删除）掉结构体中a的数据
	ps->a = NULL;//防止野指针，将其置空
	ps->top = -1;//表示为栈顶元素
	ps->capacity = 0;//将空间大小置为0
}

4.尾插

//尾插
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));
		//判断tmp扩容是否成功
		if (tmp == NULL)
		{
			//扩容失败
			perror("realloc fail");
			exit(-1);
		}
		//扩容成功	
		ps->a = tmp;
		ps->capacity *= 2;
	}
	
	//栈顶增加1，将新值放入栈顶
	
	//top初始化0时
	/*ps->a[ps->top] = x;
	ps->top++;*/
	//top初始化为-1时
	ps->top++;
	ps->a[ps->top] = x;
}

5.尾删

//尾删
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;//直接将栈顶-1
}

6.取得栈顶数据

//取得栈顶数据
STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	//top为0时
	//return ps->a[ps->top - 1];
	//top为-1时
	return ps->a[ps->top];
}

7.判断栈空

bool StackEmpty(ST* ps)
{
	assert(ps);
	/*if (ps->top == 0)
	{
		return true;
	}
	else
	{
		return false;
	}*/
	//优化
	return ps->top == -1;
}

8.栈长度

int StackSize(ST* ps)
{
	assert(ps);
	return ps->top + 1;
}

（2）队列

1.队列结构体的实现

typedef int QDataType;
typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QNode;

//队列用双指针
//用一个结构体把指针拿着
//多个值用结构体控制
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

2.初始化队列

//初始化队列
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

3.销毁队列

void QueueDestroy(Queue* pq)
{
	assert(pq);
	//记录头节点，防止后面丢失
	QNode* cur = pq->head;
	while (cur != NULL)
	{
		//记录头节点
		QNode* del = cur;
		//让cur++
		cur = cur->next;
		//释放掉之前记录的节点
		free(del);
		del = NULL;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

4.入队

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	//创造一个新节点
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	//判断新节点创建是否成功
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	//成功
	//将新节点的data赋值为x
	//next为空
	newnode->data = x;
	newnode->next = NULL;
	//判断tail指针是否为空
	if (pq->tail == NULL)
	{
		//为空时将2个指针指向新节点
		pq->head = pq->tail = newnode;
	}
	else
	{
		//不为空时，将tail的next指向新节点
		pq->tail->next = newnode;
		//tail指向新节点
		pq->tail = newnode;	
	}
	//队列长度++
	pq->size++;
}

5.出队

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* del = pq->head;
		pq->head = pq->head->next;
		free(del);
	}
	pq->size--;
}

6.取出头和尾的数据

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

7.判空及取队列长度

//判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->head == NULL && pq->tail == NULL;
}
//取队列长度
int QueueSize(Queue* pq)
{
	assert(pq);
	/*int size = 0;
	QNode* cur = pq->head;
	while (cur)
	{
		cur = cur->next;
		size++;
	}
	return size;*/
	//优化
	return pq->size;
}