栈和队列

一.栈

一种后进先出的数据结构，只允许在一端进行插入和删除操作，就像一碗米饭一样,你需要从上面才能吃到米饭，不能从碗底吃米饭，同样的栈的数据只能从栈顶取出。

1.栈的实现方法

顺序表和链表都可以实现，为什么通常采用数组实现？
数组实现栈可以将数组的尾部当作栈顶，在尾部进行插入和删除操作，时间复杂度为O(1),
链表实现栈可以采用带头结点的双向链表，无论是将头部作为栈顶还是将尾部作为栈顶，插入和删除的时间复杂度都是O(1),
从插入和删除的效率看是一样的，但是数组的空间是连续的，不会造成内存碎片，对空间的利用率更高，而链表的空间是离散的，会造成内存碎片。

2.栈实现源码

#include<stdio.h>
#include<stdlib.h>
typedef int STDatatype;

//栈的顺序结构实现
typedef struct stack
{
	STDatatype *data;
	int _size;
	int _capacity;
}stack;

//栈的初始化
void stackInit(stack* st, size_t n)
{
	st->data = (STDatatype*)malloc(sizeof(STDatatype)*n);
	st->_size = 0;
	st->_capacity = n;
}
//检查容量
void checkCapacity(stack* st)
{
	if (st->_size == st->_capacity)
	{
		int newCapacity = st->_capacity == 0 ? 1 : 2 * st->_capacity;
		st->data = (STDatatype*)realloc(st->data, sizeof(STDatatype)*newCapacity);
		st->_capacity = newCapacity;
	}
}

//入栈
void stackPush(stack* st,STDatatype val)
{
	if (st == NULL)
		return;
	checkCapacity(st);
	//尾插
	st->data[st->_size++] = val;
}

//出栈
void stackPop(stack* st)
{
	if (st == NULL)
		return;
	if (st->_size >0)
		st->_size--;
}

//获取栈顶元素
STDatatype stackTop(stack* st)
{
	return st->data[st->_size - 1];
}

//判断栈是否为空
int stackIsEmpty(stack* st)
{
	if (st == NULL || st->_size == 0)
		return 1;
	else
		return 0;
}

//求可用元素的个数
int stackSize(stack* st)
{
	if (st == NULL)
		return 0;
	else
		return st->_size;
}

//栈的销毁
void stackDestory(stack* st)
{
	free(st->data);
	st->data = NULL;
	st->_size = st->_capacity = 0;
}

void test()
{
	stack st;
	stackInit(&st,10);
	stackPush(&st, 1);
	stackPush(&st, 2);
	stackPush(&st, 3);
	stackPush(&st, 4);
	while ( !stackIsEmpty(&st))
	{
		printf("%d   ", stackTop(&st));
		printf("栈可用元素的个数为%d\n", stackSize(&st));
		stackPop(&st);
	}
	printf("\n");
}

int main()
{
	test();
	return 0;
}

二.队列

先进先出的数据结构，允许在一端进行插入操作，另一端进行删除操作。

1.队列的实现方法

数组和链表都可以实现，但链表（带头指针和尾指针的单链表）更优

2.队列实现源码

头文件queue.h

typedef int QDataType;
//定义队列的成员
typedef struct Qnode
{
	struct Qnode* _next;
	QDataType _data;
}Qnode;

//定义队列：有一个头指针和一个尾指针
typedef struct Queue
{
	Qnode* _front;
	Qnode* _rear;
	int size;
}Queue;
//初始化
void queueInit(Queue* q);
//创建节点
Qnode* createNode(QDataType val);
//入队列
void queuePush(Queue* q, QDataType val);
//出队列
void queuePop(Queue* q);
//获取队列元素的个数
int queueSize(Queue* q);
//判断是否为空
int queueEmpty(Queue* q);
//销毁
void queueDestroy(Queue* q);
//获取队头元素
QDataType queueFront(Queue* q);
//获取队尾元素
QDataType queueBack(Queue* q);

queue.c

#include<stdio.h>
#include"queue.h"
#include<stdlib.h>

//初始化
void queueInit(Queue* q)
{
	q->_front=q->_rear= NULL;
	q->size = 0;
}

//创建节点
Qnode* createNode(QDataType val)
{
	Qnode* node = (Qnode*)malloc(sizeof(Qnode));
	node->_data = val;
	node->_next = NULL;
	return node;
}

//入队列
void queuePush(Queue* q, QDataType val)
{
	Qnode* node = createNode(val);
	if (q->_front == NULL)
		q->_front = q->_rear = node;
	else
	{
		q->_rear->_next = node;
		q->_rear = node;
	}
	q->size++;
}
//出队列
void queuePop(Queue* q)
{
	if(q->_front)
	{
		Qnode* next = q->_front->_next;
		free(q->_front);
		q->_front = next;
		//删除后是否为空表
		if (q->_front == NULL)
			q->_rear = NULL;
		q->size--;
	}
	
}

//获取队列元素的个数
int queueSize(Queue* q)
{
	/*
	int num = 0;
	Qnode* cur = q->_front;
	while (cur)
	{
		num++;
		cur = cur->_next;
	}
	return num;
	*/
	return q->size;
}
//获取队头元素
QDataType queueFront(Queue* q)
{
	return q->_front->_data;
}
//获取队尾元素
QDataType queueBack(Queue* q)
{
	return q->_rear->_data;
}
//判断是否为空
int queueEmpty(Queue* q)
{
	if (q->_front == NULL)
		return 1;
		return 0;
}
//销毁
void queueDestroy(Queue* q)
{
	Qnode* cur = q->_front;
	while (cur)
	{
		Qnode* next = cur->_next;
		free(cur);
		cur = next;
	}
	q->_front = q->_rear = NULL;
	q->size = 0;
}

void test()
{
	Queue q;
	queueInit(&q);

	queuePush(&q, 1);
	queuePush(&q, 2);
	queuePush(&q, 3);
	queuePush(&q, 4);
	printf("\n队列的长度为%d\n", queueSize(&q));
	queuePop(&q);
	queuePop(&q);
	queuePop(&q);
	printf("\n队列的长度为%d\n", queueSize(&q));
	queuePush(&q, 1);
	queuePush(&q, 2);
	queuePush(&q, 3);
	queuePush(&q, 4);
	
	printf("\n队列的长度为%d\n", queueSize(&q));
	printf("开始销毁\n");
	queueDestroy(&q);
	if (queueEmpty(&q))
		printf("销毁成功\n");
	else
		printf("销毁失败\n");


}

int main()
{
	test();
	return 0;
}

3.环形队列

一种首尾相连的先进先出的数据结构，存储的元素个数是有上限的，当存储的元素个数达到上限就不再入队，可以采用数组实现

源码实现

#pragma once

#include <stdbool.h>
#include <stdlib.h>

/*
	环形队列强调的是一个循环，
	你可以把所有存储空间都利用起来，但是当已经满了的时候就不能插入了
*/

typedef struct {
	int* queue;     //队列空间，存储元素
	int headIdx;    //队头下标
	int count;      //元素个数
	int capacity;   //容量
} MyCircularQueue;

//开辟能存储k个元素大小的环形队列
MyCircularQueue* myCircularQueueCreate(int k) {
	MyCircularQueue* cq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
	cq->headIdx = 0;
	cq->count = 0;
	cq->capacity = k;
	cq->queue = (int*)malloc(sizeof(int)* k);
	return cq;
}

//判空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
	if (obj == NULL)
		return true;
	return obj->count == 0;
}

//判断是否已满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
	if (obj == NULL)
		return false;
	return obj->count == obj->capacity;
}

//入队
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
	if (obj == NULL)
		return false;

	if (myCircularQueueIsFull(obj))
		return false;

	obj->queue[(obj->headIdx + obj->count) % obj->capacity] = value;
	++obj->count;
	return true;
}

//出队
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
	if (obj == NULL)
		return false;
	if (myCircularQueueIsEmpty(obj))
		return false;

	obj->headIdx = (obj->headIdx + 1) % obj->capacity;
	--obj->count;
	return true;
}

//返回队头元素
int myCircularQueueFront(MyCircularQueue* obj) {
	if (myCircularQueueIsEmpty(obj))
		return -1;
	return obj->queue[obj->headIdx];
}

//返回队尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
	if (myCircularQueueIsEmpty(obj))
		return -1;
	
	//从头到尾是连续的
	int tailIdx = (obj->headIdx + obj->count - 1) % obj->capacity;
	return obj->queue[tailIdx];
}

//释放环形队列从堆上申请的空间
void myCircularQueueFree(MyCircularQueue* obj) {
	if (obj == NULL)
		return;
	free(obj->queue);
	free(obj);
}

//打印环形队列
void printCircleQueue(MyCircularQueue* obj)
{
	if (obj == NULL || obj->count == 0)
		return;
	
	int startIdx = obj->headIdx;
	int step = 0;
	while (step < obj->count)
	{
		int curIdx = (startIdx + step) % obj->capacity;
		printf("%d ", obj->queue[curIdx]);
		++step;
	}
	printf("\n");
}