栈和队列的基本操作与实现——详解

栈分为静态栈和链式栈，因为静态栈所有操作时间复杂度为O( 1 ),故常使用静态栈。

功能：

1.初始化  2.出栈  3.入栈 

 4.取栈顶元素  5. 取栈元素个数  6.检测栈是否为空

#pragma once

#include<stdio.h>
#include<windows.h>
#include<assert.h>
#include<malloc.h>
#define  STACKINCREMENT    10
#define MAX_SIZE 100
typedef int DataType;

typedef struct Stack
{
	DataType  *_st;
	size_t _size;
	size_t _capacity;		//容量
}Stack;

void StackInit(Stack *s, size_t capacity);
void StackDestory(Stack *s);
void StackPush(Stack *s, DataType x);
void StackPop(Stack*s);
DataType StackTop(Stack *s);
size_t StackSize(Stack *s);
size_t StackEmpty(Stack *s);
void StackPush(Stack *s, DataType x);



void StackInit(Stack *s, size_t capacity)		//初始化
{
	assert(s && capacity>0);
	s->_st = (DataType *)malloc(sizeof(DataType)*capacity);
	assert(s->_st);
	s->_size = 0;
	s->_capacity = capacity;
}




void StackPush(Stack *s, DataType x)		//入栈
{
	assert(s);
	if (s->_size == s->_capacity)
	{
		s->_capacity *= 2;
		s->_st = (DataType*)realloc(s->_st, sizeof(DataType)*s->_capacity);
	}

	s->_st[s->_size++] = x;
}


void StackPop(Stack*s)		//出栈
{
	assert(s && s->_size > 0);
	--s->_size;
}

DataType StackTop(Stack *s)		//取栈顶
{
	assert(s && s->_size > 0);
	return s->_st[s->_size - 1];
}


size_t StackSize(Stack *s)		//取栈元素个数
{
	assert(s);
	return s->_size;
}


size_t StackEmpty(Stack *s)		//判空
{
	return s->_size;
}

void Teststack()
{
	Stack s;
	StackInit(&s, 3);
	StackPush(&s, 1);
	StackPush(&s, 2);
	StackPush(&s, 3);
	StackPush(&s, 4);
	StackPush(&s, 5);
	StackPush(&s, 6);

	while (StackEmpty(&s) != 0)
	{
		printf("%d ", StackTop(&s));
		StackPop(&s);
	}

	printf("\n");
}

—————————————————————————————————————————————

队列若使用静态结构会出现数组溢出的情况，所以通常使用链式结构

#include<stdio.h>
#include<windows.h>
#include<assert.h>
typedef int DataType;
typedef struct QueueNode
{
	DataType _data;    //链式队列
	struct QueueNode* _next;
}QueueNode;

typedef struct Queue
{
	QueueNode* _head;//队头指针
	QueueNode* _tail;//队尾指针
}Queue;

void QueueInit(Queue* q)//队列初始化
{
	q->_head = q->_tail = (QueueNode*)malloc(sizeof(QueueNode));
	assert(q->_head);
	q->_tail->_next = NULL;
}



void QueuePush(Queue* q, DataType x)//入队
{
	QueueNode *newnode = (QueueNode*)malloc(sizeof(QueueNode));
	assert(newnode);
	newnode->_data = x;
	newnode->_next = NULL;
	q->_tail->_next = newnode;		//将头节点连接在newnode上
	q->_tail = newnode;
}



void QueuePop(Queue* q)//出队
{
	assert(q);
	if (q->_head == q->_tail)	//没有结点
	{
		return;
	}

	QueueNode *p = q->_head->_next;

	if (q->_head->_next == q->_tail)
	{
		q->_tail = q->_head;
		free(p);
		q->_head->_next = NULL;
	}

	q->_head->_next = p->_next;
	
}



DataType QueueFront(Queue* q)//取队头数据
{
	assert(q);
	if (q->_head == q->_tail)
	{
		return 0;
	}
	return (q->_head->_next)->_data;
}



DataType QueueBack(Queue* q)//取队尾数据
{
	assert(q);
	if (q->_head == q->_tail)
	{
		return 0;
	}
	QueueNode *p = q->_head->_next;
	while (p != q->_tail)
	{
		p = p->_next;
	}
	return p->_data;
}


size_t QueueSize(Queue* q)//计算队列长度
{
	assert(q);
	if (q->_head == q->_tail)
	{
		return 0;
	}
	QueueNode *flag = q->_head->_next;
	size_t i = 0;
	while (flag != q->_tail)
	{
		flag = flag->_next;
		i++;
	}
	return i + 1;
}


int QueueEmpty(Queue* q)//判断队列是否为空
{
	assert(q);
	if (q->_head == q->_tail)
	{
		return 0;
	}
	return 1;
}

void Print(Queue* q)
{
	assert(q);
	while (QueueEmpty(q) != 0)
	{
		printf("%d ", QueueFront(q));
		QueuePop(q);
	}
}


void TestQueue()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	Print(&q);
	
}