栈+队列

顺序栈
Static.h

#ifndef _STACK_H_
#define _STACK_H_

#define SIZE 10


typedef enum {FALSE, TRUE}  BOOL;

typedef int Data;
typedef struct stack
{
	Data data[SIZE];         // 栈存储空间
	int top; // 栈顶元素的下标
}Stack;


// 初始化栈
void Init(Stack *s);

//判断空栈
BOOL Empty(Stack *s);

//判断满栈
BOOL Full(Stack *s);



//入栈
void Push(Stack *s,Data data);

//出栈
void Pop(Stack *s);

//获取栈顶元素
Data GetTop(Stack *s);


#endif

Static.c

#include "stack.h"
#include <stdlib.h>

void Init(Stack *s)
{
	if (NULL==s)
		return;
	
	s->top=-1;
}

BOOL Empty(Stack *s)
{
	if (NULL==s)
		return;
	
	if(s->top==-1)
		return TRUE;
	return FALSE;
}

BOOL Full(Stack *s)
{
	if (NULL==s)
		return;
	
	if(s->top==SIZE-1)
		return TRUE;
	return FALSE;
}

void Push(Stack *s,Data data)
{
	if (NULL==s)
		return;
	if(TRUE==Full(s))
		return;
	
	s->data[++s->top]=data;
}

void Pop(Stack *s)
{
	if (NULL==s)
		return;
	if(TRUE==Empty(s))
		return;
	
	s->top--;
}

Data GetTop(Stack *s)
{
	if (NULL==s)
		return;
	
	if(TRUE==Empty(s))
		exit(-1);
	return s->data[s->top];
}

main.c

#include <stdio.h>
#include "stack.h"

int main()
{
	Stack s;
	Init(&s);
	
	int i;
	for(i=0;i<10;i++)
	{
		Push(&s,i);
	}
	
	while(!Empty(&s))
	{
		Data data=GetTop(&s);
		printf("%d\n",data);
		
		Pop(&s);
	}
	printf("栈结束\n");
	
	return 0;
}

链式栈
Static.h

#ifndef _STACK_H_
#define _STACK_H_

#define SIZE 10


typedef enum {FALSE, TRUE}  BOOL;

typedef int Data;
typedef struct _node
{
	Data data;         // 栈存储空间
	struct _node *next; // 栈顶元素的下标
}Node;
typedef struct _stack
{
	Node head;
}Stack;


// 初始化栈
void Init(Stack *s);

//判断空栈
BOOL Empty(Stack *s);


//入栈
void Push(Stack *s,Data data);

//出栈
void Pop(Stack *s);

//获取栈顶元素
Data GetTop(Stack *s);


#endif

Static.c

#include "Stack.h"
#include <stdlib.h>

void Init(Stack *s)
{
	if (NULL==s)
		return;
	
	s->head.next=NULL;
}

BOOL Empty(Stack *s)
{
	if (NULL==s)
		return FALSE;
	
	if(s->head.next==NULL)
		return TRUE;
	
	return FALSE;
}



void Push(Stack *s,Data data)
{
	if (NULL==s)
		return;
	
	Node *node =(Node *)malloc(sizeof(Node)/sizeof(char));
	
	if(node==NULL)
		return;
	
	node->data=data;
	node->next=s->head.next;
	(s->head).next=node;
}

void Pop(Stack *s)
{
	if (NULL==s)
		return;
	
	if(TRUE==Empty(s))
		return;
	
	Node *tmp=(s->head).next;
	(s->head).next=tmp->next;
	free(tmp);
}

Data GetTop(Stack *s)
{
	if (NULL==s)
		return;
	
	if(TRUE==Empty(s))
		exit(-1);
	
	return (s->head).next->data;
}

main.c

#include <stdio.h>
#include "Stack.h"

int main()
{
	Stack s;
	Init(&s);
	
	int i;
	for(i=0;i<10;i++)
	{
		Push(&s,i);
	}
	
	while(!Empty(&s))
	{
		Data data=GetTop(&s);
		printf("%d\n",data);
		
		Pop(&s);
	}
	printf("栈结束\n");
	
	return 0;
}

链式队列
Queue.h

#ifndef _QUEUE_H_
#define _QUEUE_H_

#define SIZE 10


typedef enum {FALSE, TRUE}  BOOL;

typedef int Data;
typedef struct _node
{
	Data data;         // 栈存储空间
	struct _node *next; // 栈顶元素的下标
}Node;
typedef struct queue
{
	Node *front;
	Node *rear;
}Queue;


// 初始化栈
void Init(Queue *q);

//判断空栈
BOOL Empty(Queue *q);


//入栈
void Push(Queue *q,Data data);

//出栈
void Pop(Queue *q);

//获取栈顶元素
Data GetTop(Queue *q);


#endif

Queue.c

#include "Queue.h"
#include <stdlib.h>

void Init(Queue *q)// 初始化栈
{
	if (NULL==q)
		return;
	
	q->front=NULL;
	q->rear=NULL;
}

BOOL Empty(Queue *q)//判断空栈
{
	if (NULL==q)
		return FALSE;
	
	if(q->front==NULL)
		return TRUE;
	
	return FALSE;
}



void Push(Queue *q,Data data)//入栈
{
	if (NULL==q)
		return;
	
	Node *node =(Node *)malloc(sizeof(Node)/sizeof(char));
	
	if(node==NULL)
		return;
	
	node->data=data;
	node->next=NULL;
	if(q->rear!=NULL)
	{
		q->rear->next=node;
		q->rear=node;
	}
	else
	{
		q->rear=node;
		q->front=node;
	}
	
}

void Pop(Queue *q)//出栈
{
	if (NULL==q)
		return;
	
	if(TRUE==Empty(q))
		return;
	
	Node *tmp=q->front;
	q->front=tmp->next;
	free(tmp);
	
	if(q->front==NULL)
	{
		q->rear=NULL;
	}
}

Data GetTop(Queue *q)//获取栈顶元素
{
	if (NULL==q)
		return;
	
	if(TRUE==Empty(q))
		exit(-1);
	
	return q->front->data;
}

main.c

#include <stdio.h>
#include "Queue.h"

int main()
{
	Queue q;
	Init(&q);
	
	int i;
	for(i=0;i<10;i++)
	{
		Push(&q,i);
	}
	
	while(!Empty(&q))
	{
		Data data=GetTop(&q);
		printf("%d\n",data);
		
		Pop(&q);
	}
	printf("栈结束\n");
	
	return 0;
}

顺序队列
Queue.h

#ifndef _QUEUE_H_
#define _QUEUE_H_

#define SIZE 10


typedef enum {FALSE, TRUE}  BOOL;

typedef int Data;

typedef struct queue
{
	Data data[SIZE];
	int front;
	int rear;
}Queue;


// 初始化队列
void Init(Queue *q);

//判断空队列
BOOL Empty(Queue *q);

//判断满队列
BOOL Full(Queue *s);

//入队列
void Push(Queue *q,Data data);

//出队列
void Pop(Queue *q);

//获取队头元素
Data GetTop(Queue *q);


#endif

Queue.c

#include "Queue.h"
#include <stdlib.h>

void Init(Queue *q)// 初始化队列
{
	if (NULL==q)
		return;
	
	q->front=0;
	q->rear=0;
}

BOOL Empty(Queue *q)//判断空队列
{
	if (NULL==q)
		return FALSE;
	
	if(q->front==q->rear)
		return TRUE;
	
	return FALSE;
}

BOOL Full(Queue *q)
{
	if (NULL==q)
		return FALSE;
	if((q->rear+1)%SIZE==q->front)
		return TRUE;
	
	return FALSE;
}



void Push(Queue *q,Data data)//入队列
{
	if (NULL==q)
		return;
	
	if(Full(q)==TRUE)
		return;
	
	q->rear=(q->rear+1)%SIZE;
	q->data[q->rear]=data;
	
	
}

void Pop(Queue *q)//出队列
{
	if (NULL==q)
		return;
	
	if(TRUE==Empty(q))
		return;
	
	
	q->front=(q->front+1)%SIZE;
}

Data GetTop(Queue *q)//获取队头元素
{
	if (NULL==q)
		return;
	
	if(TRUE==Empty(q))
		exit(-1);
	
	return q->data[(q->front+1)%SIZE];
}
main.c

#include <stdio.h>
#include “Queue.h”

int main()
{
Queue q;
Init(&q);

int i;
for(i=0;i<10;i++)
{
	Push(&q,i);
}

while(!Empty(&q))
{
	Data data=GetTop(&q);
	printf("%d\n",data);
	
	Pop(&q);
}
printf("栈结束\n");

return 0;

}