栈和队列

栈的存储结构：
①顺序栈
②链栈

一.顺序栈:

顺序栈的基本操作：

//栈的初始化
//构建一个结构体 		 
typedef int elemtype;		 //elemtype可设置为不同的类型 如inte 
typedef struct SequenStack
{
	elemtype date[MAXSIZE];//定义顺序栈为一维数组 
	int top;							 //top为栈顶指针 
}SequnStack;

//顺序栈的初始化 ：构造一个空栈 
SequenStack * Init_SequenStack()
{
	Squence *S;           //顺序栈的指针变量 
	S = (SequenStack *) malloc (sizeof(Sizeof(SequenStack)));//申请空间且S指向这个空间 
	if(S == NULL) return S;  //如果申请失败就返回空指针 
	
	S->top = -1;
	return S;
}

int main()
{
  SequenStack *S;          
  S = Init_SequenStack();
  if(S == NULL) printf("申请空间失败了！");
	else
	.
	.
	.
	
	return 0;
}
---------------------------------------------------------------
//判栈空 
int SequenStack_Empty(SequenStack *S)
{
	if(S->top == -1) return 1;
	else return 0;
}
//判栈满 
int SequenStack_Full(SequenStack *S)
{
	return (S->top+1);
}

//入栈
int Push_SequenStack(SequenStack *S, elemtype x)
{
	if(S->top >= MAXSIZE-1) return 0;//满了吧，插入失败	
	S->top++;
	S->date[S->top] = X;
	return 1;                        //插入成功 返回x 
} 
//出栈
int Pop_SequenStack(SequenStack *S, elemtype x)//这x相对于打工人 
{
	if(S->top == -1) return 0;     //都空了，删除失败 
	S->top--;											 
	//相当于删除，其实没有删 -_-但是重新入栈会覆盖它				
	*x = S->date[S->top+1];        //把原栈顶元素赋值给x，然后输出它 
	return 1;                      //删除成功 返回x 
}

二.链栈:

//链栈的定义 
typedef struct
{
	int date;
	struct LinkStackNode * next;
}LinkStackNode, LinkedStack;
LinkedStack top;

//链栈初始化 
LinkedStack Init_LinkedStack()
{
	LinkedStack top = (LinkedStackNode *) molloc (sizeof(LinkedStackNode));
	if(top != NULL) top->next = NULL;
	return top;
}

//入栈
int push(LinkedStack top, int x)
{
	LinkedStackNode *node;	
	node = (LinkedStackNode *) malloc (sizeof(LinkedStackNode));
	
	if(node == NULL) return 0;//申请空间失败 
	else
	{
		node->date = x;
		node->next = top->next;
		top->next = node;
		return 1;
	}
} 

//出栈
int pop(LinkedStack top) 
{
	int x;
	LinkedStackNode *node;
	if(top->next == NULL) return 0;
	else
	{
		node = top->next;
		x = node->date;
		top->next = node->next;
		free(node);
		printf("%d\n", x); 
		return 1;
	}
}

//判空
int empty(LinkedStack top) 
{
	if(top->next == NULL) return 1;
	else  return 0;
}

队列：先进后出

队列的储存结构：
①顺序存储结构:用数组->顺序队列 优化后变为更好用的 循环队列
②连式储存结构:用链表->链队列

队列可用stl里的 queue < int> q 很好用！

循环队列

//循环队列的定义 
typedef struct SequenQueue 
{
	int date[MAXSIZE];
	int front;
	int rear; 
}SequenQueue;

//循环队列的初始化
SequenQueue *INIT_SequenQueue()
{
	SequenQueue *Q;
	Q = (SequenQueu *) malloc (sizeof(SequenQueue));
	if(Q != NULL)
	{
		Q->front = 0;
		Q->rear  = 0;	
	}
	return Q;//返回循环队列的首地址 
} 

//判队满 牺牲一个空间来确定是否堆满
int full(SequenQueue *Q)
{
	if((Q->rear+1)%MAXSIZE == Q->front) return 1;//队满
	else return 0;		 
}

//判对空 
int empty(SeqeunQueue *S)
{
	if(S->front == Q->rer) return 1;
	else return 0;	
} 

//入队
int Enter(SequenQueue *Q, int x)
{
	if(full(Q)) return 0;//队列满了
	Q->date[Q->rear] = x;//插入x 
	Q->rear = (Q->rear+1) % MAXSIZE;//尾指针+1 
	return 1; 
} 

//出队
int Delete(SequenQueue *Q)
{
	if(Q->front == Q->rear) return 0;//队列为空出队失败	
	else
	{
		x = Q->date[Q->front];
		Q->front = (Q->front+1) % MAXSIZE;//front+1
		return 1; 
	}
}

这里有个队列的题目
它是直接类似队列的东西来做的
不想我搞了一大堆的结构题链表啥的
所以做题还是要避繁趋简！
题目：海港
题解：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<iomanip>
#include<string>
using namespace std;
int book[100001],a[300002],queue[300002];//队列
int main()
{
	int n,t,k,head=0,country=0,tail=0;	//定义一大堆...
	cin>>n;
	for (int i=1;i<=n;++i)
	{
		cin>>t>>k;
		for (int j=1;j<=k;++j)
		{
			queue[++tail]=t;	//用队列储存时间!!!
			cin>>a[tail];//输入
			if(book[a[tail]]++==0)
				++country;	//如果以前没有这个国籍，则给国籍总数加1
		}
		while (t-queue[head]>=86400)//重要部分：如果第一个人到达的时间已经大于当前时间
			if(--book[a[head++]]==0)//跳到下一个人，如果这个人是一个国籍的唯一一个人
				--country;	//暂且不再有这个国籍
		cout<<country<<endl;	//输出
	}
	return 0;
}

链式队列

//定义
typedef struct QueueNode
{
	int date;
	struct QueueNode *next; //指向下个结点的指针 
} LinkedQueueNode;				//链队列结点的结构类型 
typedef struct LQueue
{
	LinkedQueueNode *front; //对头指针 
	LinkedQueueNode *rear;	//队尾指针 
}LQueue, *LinkedQueue;		//链队列的结构类型 

//初始化
LinkedQueueNode Init_LinkQueue()
{
	LinkedQueue Q = (LinkedQueue) malloc (sizeof(LQueue));
	LinkedQueueNode * head = (LinkedQueueNode *) malloc (sizeof(LinkedQueueNode));
	
	if(head!=NULL && Q!=NULL)
	{
		head->next = NULL;
		Q->front = head;
		Q->rear  = head;
	}
	return Q;
}

//判空
int empty(LinkedQueue Q)
{
	if(Q->front == Q->rear) return 1;
	else return 0;	
}

//入队
int Enter(LinkedQueue Q, int x)
{
	LinkedQueueNode * node;
	node = (LinkedQueueNode *) malloc (sizeof(LinkedQueueNode));
	if(node == NULL) return 0;
	
	node->date = x;       //设置新结点的数据域赋值 
	node->next = NULL;		//设置新结点的指针域为空 
	Q->rear->next = node;	//将新结点插入队尾 
	Q->rear = node;				//设置设置尾指针指向新的队尾元素 
	return 1;
}

//出队 
int Delete(LinkedQueue Q)
{
	int x;
	LinkedQueueNode * node;
	if(Q->front == Q->rear) return 0;//队列为空
	else
	{
		node = Q->front->next;      //node指向原队顶元素 
		x = node->date;							//将原队顶元素的数组赋值给 x 
		Q->front->next = node->next;//头指针Q移动到下一个结点 
		因为第一个结点是不存如何数据的头节点
		if(node == Q->rear)         //若队列仅只有一个数据元素，置队列为空 
			Q->rear = Q->front;				
		free(node);									//释放出队元素 
		return 1;	
	} 
}