栈、队列的基本操作

栈

数组方法实现、利用动态扩容
Stack.h

typedef int DataType;
typedef struct  Stack {
	DataType*  array;
	int capacity;
	int size;      //代表栈内有效元素数量,也代表栈顶指针
}Stack;

//初始化
void StackInit(Stack* ps);
//压栈
void StackPush(Stack* ps,DataType data);
//出栈
void StackPop(Stack* ps);
//获取栈顶元素
DataType StackTopElem(Stack* ps);
//获取栈内元素数量
int StackElem(Stack* ps);
//栈判空
int StackEmpty(Stack* ps);
//销毁
void StackDestroy(Stack* ps);

Stack.c

//检测容量
void CheckCapacity(Stack* ps) {
	assert(ps);
	if (ps->capacity == ps->size) {
		ps->capacity += 3;
		ps->array = (DataType*)realloc(ps->array, sizeof(DataType)* ps->capacity);
	}
}

//初始化
void StackInit(Stack* ps) {
	assert(ps);
	ps->array = ( DataType* ) malloc(sizeof(DataType) * 3);
	if (ps->array == NULL) {
		assert(0);
		return;
	}
	ps->capacity = 3;
	ps->size = 0;
}

//压栈
void StackPush(Stack* ps, DataType data) {
	//检测空间剩余
	CheckCapacity(ps);

	ps->array[ps->size++] = data;
}


//出栈
void StackPop(Stack* ps) {
	assert(ps);
	if (StackEmpty(ps)==0)
		return;
	ps->size -= 1;
}

//获取栈顶元素
DataType StackTopElem(Stack* ps) {
	assert(ps);
	return ps->array[ps->size-1];
}

//获取栈内元素数量
int StackElem(Stack* ps) {
	assert(ps);
	return ps->size;
}

//栈判空.   空返回0,不空返回1
int StackEmpty(Stack* ps) {
	assert(ps);
	if (0 == ps->size)
		return 0;
	return 1;
}

//销毁
void StackDestroy(Stack* ps) {
	assert(ps);
	if (ps->array) {
		free(ps->array);
		ps->capacity = 0;
		ps->size = 0;
	}
}

void main() {
	Stack s;

	StackInit(&s);

	StackPush(&s, 1);
	StackPush(&s, 2);
	StackPush(&s, 3);
	
	printf("%d\n", StackTopElem(&s));
	printf("%d\n", StackElem(&s));

	StackPush(&s, 4);    //触发扩容
	StackPush(&s, 5);

	printf("%d\n", StackTopElem(&s));
	printf("%d\n", StackElem(&s));
	
	StackPop(&s);
	printf("%d\n", StackTopElem(&s));
	printf("%d\n", StackElem(&s));

	int ret=StackEmpty(&s);
	printf("%d\n", ret);
	StackDestroy(&s);

	system("pause");
}

队列

单链表实现
Queue.h

typedef int DataType;
typedef struct QNode
{
	struct QNode* Next;
	DataType data;
}QNode;

typedef struct Queue
{
	QNode*  front; // 指向队头元素 
	QNode*  back; // 指向队尾元素 
}Queue;

//初始化
void QueueInit(Queue* q);
//入队
void QueuePush(Queue* q, DataType data);
//出队
void QueuePop(Queue* q);
//队头元素
DataType QueueFront(Queue* q);
//队尾元素
DataType QueueBack(Queue* q);
//元素个数
int QueueSize(Queue* q);
//队判空
int QueueEmpty(Queue* q);
//队销毁
void QueueDestroy(Queue* q);

Queue.c

//创建新的节点
QNode* CreatNewNode(DataType data) {
	QNode* NewNode = (QNode*)malloc(sizeof(QNode));
	if (NewNode == NULL){
		assert(0);
		return NULL;
	}
	NewNode->next = NULL;
	NewNode->data = data;
	return NewNode;
}

//初始化
void QueueInit(Queue* q) {
	assert(q);
	q->front = q->rear = NULL;
}

//入队
void QueuePush(Queue* q, DataType data) {
	assert(q);
	QNode* NewNode = CreatNewNode(data);
	if (QueueEmpty(q)) {
		q->front = q->rear = NewNode;
	}
	else {
		q->rear->next = NewNode;
		q->rear = NewNode;
	}
}

//出队
void QueuePop(Queue* q) {
	assert(q);
	if (QueueEmpty(q)) {
		return ;
	}
	else {
		QNode* Qtmp = q->front;
		if (Qtmp->next == NULL) {
			q->front = q->rear = NULL;
		}
		q->front = Qtmp->next;
	}
}

//队头元素
DataType QueueFront(Queue* q) {
	assert(q);
	if (QueueEmpty(q)) {
		return;
	}
	else {
		return q->front->data;
	}
}

//队尾元素
DataType QueueRear(Queue* q) {
	assert(q);
	if (QueueEmpty(q)) {
		return -1;
	}
	else {
		return q->rear->data;
	}
}

//元素个数
int QueueSize(Queue* q) {
	assert(q);
	int count = 0;
	QNode* QCur = q->front;
	while (QCur!= NULL) {
		count++;
		QCur = QCur->next;
	}
	return count;
}

//队判空
int QueueEmpty(Queue* q) {
	assert(q);
	if (q->front == NULL)
		return 1;
	return 0;
}

//队销毁
void QueueDestroy(Queue* q) {
	QNode* QCur = q->front;
	while (QCur!=NULL) {
		q->front = QCur->next;
		free(QCur);
		QCur = q->front;
	}
	q->front = q->rear = NULL;
}

void  main() {
	Queue q;

	QueueInit(&q);

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

	QueuePop(&q);

	printf("%d\n",QueueFront(&q));
	printf("%d\n",QueueRear(&q));
	printf("%d\n",QueueSize(&q));

	QueueDestroy(&q);

	system("pause");
}