数据结构----关于栈与队列（用顺序表实现栈，用链表实现队列）

一、栈

栈：只允许在固定的一端进行插入和删除元素操作。进入和删除操作的一端称为栈顶，另一端为栈底。

栈特性：后进先出

栈功能：将数据从一个序列改变到另一种序列

我们用顺序表来实现一个栈~

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int Datatype;

#define MAX_SIZE (100)

typedef struct stack_{
	Datatype arry[MAX_SIZE];
	int top;
}Stack;

//初始化
void stackInit(Stack *pS)
{
	assert(pS);
	pS->top = 0;
}

//入栈
void stackPush(Stack *pS, Datatype data)
{
	assert(pS);
	assert(pS->top< MAX_SIZE);
	pS->arry[pS->top++] = data;
}

//出栈
void stackPop(Stack *pS)
{
	assert(pS);
	assert(pS->top>0);
	pS->top--;
}

//看一下栈顶
Datatype stackTop(Stack *pS)
{
	assert(pS);
	return pS->arry[pS->top-1];
}

// 判断为空， 1 表示空，0 表示非空
Datatype stackIsempty(Stack *pS)
{
	return pS->top == 0 ? 1 : 0;
}

//个数
Datatype stackSize(Stack *pS)
{
	return pS->top;
}

//拷贝
//void stackCpy(Stack *pDest, Stack *pSrc)
//{
//	pDest->top = pSrc->top;
//	memcpy(pDest->arry, pSrc->arry, sizeof(Datatype)*pDest->top);
//}

void Print(Stack *pS)
{
	assert(pS);
	int i;
	for (i = 0; i < pS->top; i++)
	{
		printf("%d ", pS->arry[i]);
	}
	printf("\n");
}

void TestStack()
{
	Stack stack;
	stackInit(&stack);
	//stackPush(&stack, 1);
	//stackPush(&stack, 2);
	//stackPush(&stack, 3);
	//stackPush(&stack, 4);
	//stackPush(&stack, 4);
	//stackPush(&stack, 4);
	//stackPush(&stack, 4);
	//Print(&stack);
	//
	//stackPop(&stack);
	//Print(&stack);
	//
	//int a=stackTop(&stack);
	//printf("top=%d\n", a);

	//stackIsempty(&stack);

	//int b=stackSize(&stack);
	//printf("size=%d\n", b);
	////Stack stack1;
	////stackCpy(&stack,&stack1);
	//
	//Print(&stack);
}

二、队列

1.只允许在一端进行插入数据，在另一端删除数据

2.进行插入操作的一端称为队尾（入队列）

3.进行删除操作的一端称为队头（出队列）

4.队列具有先进先出的特性

一个小小的面试题：

循环队列如何判断队列空和满呢？

1.少用一个存储单元

2.设置一个标记

3.设置一个计数器

链式队列：

特殊的单链表，只在单链表上进行头删尾插的操作

单链表实现代码如下~

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>

typedef int Qdatatype;
//链表结构体
typedef struct QNode{
	Qdatatype data;
	struct Node *pNext;
}QNode;

//首尾结点结构体
typedef struct Queue{
	QNode *pFront;
	QNode *pRear;
	int size;
}Queue;

//初始化
void QueueInit(Queue *PQ)
{
	assert(PQ);
	PQ->pFront = PQ->pRear = NULL;
	PQ->size = 0;
}

//入队列
void QueuePush(Queue *PQ,Qdatatype data)
{
	assert(PQ);
	PQ->size++;
	QNode *pNewNode = (QNode *)malloc(sizeof(QNode));
	assert(pNewNode);

	pNewNode->data = data;
	pNewNode->pNext = NULL;
	//特殊情况
	if (PQ->pRear== NULL)
	{
		PQ->pFront = PQ->pRear = pNewNode;
		return;
	}
	//一般情况
	PQ->pRear->pNext= pNewNode;
	PQ->pRear = pNewNode;
}

//出队列
void QueuePop(Queue *PQ)
{
	assert(PQ);
	assert(PQ->size > 0);
	PQ->size--;
	//一般情况
	QNode *OldFront = PQ->pFront;
	PQ->pFront = PQ->pFront->pNext;
	free(OldFront);
	//
	if (PQ->pFront==NULL)
	{
		PQ->pRear = NULL;
	}

}

int QueueTop(Queue *PQ)
{
	assert(PQ);
	assert(PQ->size > 0);
	return PQ->pFront->data;
}

// 1 空 0 不空
int QueueIsEmpty(Queue *pQ)
{
	pQ->size == 0 ? 1 : 0;
}

//个数
int QueueSize(Queue *pQ)
{
	return pQ->size;
}
//打印
void Print(QNode *PQ)
{
	assert(PQ);
	for (PQ = 0; PQ!= NULL; PQ = PQ->pNext)
	{
		printf("%d\n ", PQ->data);
	}
	printf("\n");
}
void TestQueue()
{
	Queue queue;
	QueueInit(&queue);//初始化
	QueuePush(&queue, 1);//进队列
	QueuePush(&queue, 2);
	QueuePush(&queue, 3);
	//Print(&queue);

	QueuePop(&queue);//出队列

	int a=QueueTop(&queue);//队列最上面的
    printf("top=%d\n", a);

	QueueIsEmpty(&queue);

	int b = QueueSize(&queue);
	printf("size=%d\n", a);


}