数据结构之栈和队列的简单实现

注意：此文为最基本的栈和队列的实现

顺序栈

/*
**顺序栈 
*/ 
#include <stdio.h>
#include <stdlib.h>
#define MAX 10

typedef struct{
	int data[MAX];
	int top;
}ArrStack;

void InitStack(ArrStack *s){
	s->top=-1;	
}

void pushStack(ArrStack *s){
	for(int i=0;i<10;i++){
		s->top++;
		s->data[s->top]=i;
	}
}

int PopStack(ArrStack *s){
	if(s->top==-1)
		return 0;
	s->top--;
	return 1;
}

void show(ArrStack *s){
	int n=s->top;
	for(int i=0;i<s->top;i++){
		printf("%d\n",s->data[n]);
		n--;	
	}
}

int main(){
	ArrStack asd;
	InitStack(&asd);
	pushStack(&asd);
	show(&asd);
	PopStack(&asd);
	show(&asd);
	return 0;
}

链栈

/*
**链栈 
*/
#include <stdio.h>
#include <stdlib.h>

typedef struct LinkStack{
	int data;
	struct LinkStack *Next;
}LinkStack,*LinkStackPtr;

typedef struct Pointer{
	LinkStackPtr top;
	LinkStackPtr Bottom;
}pointer;

//初始化栈 
void initStack(Pointer &p){
	LinkStackPtr lsp=(LinkStackPtr)malloc(sizeof(LinkStack));
	p.top=lsp;
	p.Bottom=lsp;
	p.Bottom->data=0;
	p.top->Next=NULL;
}

//创建栈 
void CreateStack(Pointer &p){
	LinkStackPtr lsp;
	for(int i=1;i<10;i++){
		lsp=(LinkStackPtr)malloc(sizeof(LinkStack));
		p.top=lsp;
		p.top->Next=p.Bottom;
		p.top->data=i;
		p.Bottom=lsp;

	}
}

//出栈
int OutStack(Pointer &p){
	int x=p.top->data;
	p.top=p.top->Next;
	return x;
} 

int main(){
	Pointer ptr;
	initStack(ptr);
	CreateStack(ptr);
	printf("%d\n",ptr.top->data);
	printf("%d\n",OutStack(ptr));
	return 0;
}

顺序队列——循环队列

/*
**顺序结构 
**循环队列 
*/ 
#include <stdio.h>
#include <stdlib.h>
#define MAX 100

typedef struct SqQueue{
	int data[MAX];
	int front;	//头指针 
	int rear;	//尾指针 
}SqQueue;

//队列初始化 
void InitQueue(SqQueue *S){
	S->front=0;
	S->rear=0;
}

//判断队列是否为空 
int EmptyQueue(SqQueue *S){
	if(S->front==S->rear)
		return 1;
	else
		return 0;
}

//入队
void InQueue(SqQueue *S){
	if((S->rear+1)%MAX==S->front)
		printf("队列已满\n");	
	else{
		//这里直接赋值,也可用scanf 
		for(int i=0;i<10;i++){
			
			 S->data[S->rear]=i;
			 S->rear=(S->rear+1)%MAX;	//rear指针向后移一位，若到最后一位，则转到数组头部 
			  
		}
	}	
}

//出队
int OutQueue(SqQueue *S){
	if(EmptyQueue(S)){
		return 0;
	}
	int x=S->data[S->front];
	S->front=(S->front+1)%MAX;	
	return x;
} 

int main(){
	SqQueue sqQueue;
	InitQueue(&sqQueue);
	InQueue(&sqQueue);
	for(int i=0;i<10;i++){
		int l=OutQueue(&sqQueue);
		printf("%d\n",l);
	}
	return 0;
}

链式队列

/*
**链式队列 
*/ 
#include <stdio.h>
#include <stdlib.h>

typedef struct QNode{
	int data;
	struct QNode *next;
}QNode, *QueuePtr;

typedef struct{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;

int InitQueue(LinkQueue &Q)
{
	//申请一个节点空间，然后将队头队尾指针指向它
    QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
	if(!p) return 0;
	Q.front = p;
	Q.rear = p;
	Q.front->next = NULL;
	return 1;
}

int CreateQueue(LinkQueue &Q, int n)
{
	int i;
	QueuePtr s;
	if(!Q.front) return 0;
	for( i=1; i<=n; i++)
	{
		//申请一个节点，并初始化其值
        s=(QueuePtr)malloc(sizeof(QNode));
		scanf("%d",&(s->data));
		//插入队列,由于先进先出，所以只能插入到队尾
		Q.rear->next=s;
		s->next = NULL;
		Q.rear = s;
	}
	return 1;
}

//出队，并将出对的元素放到e中
int DeQueue(LinkQueue &Q, int &e)
{
    if(Q.front == Q.rear) return 0;
	//取出队头指针的数据
	QueuePtr  p =Q.front->next; 
	e = p->data;
	Q.front = Q.front ->next;	
	if(Q.rear == p)
		Q.rear = Q.front;
	free(p);
}

int PrintQueue(LinkQueue Q)
{
	QueuePtr  p=Q.front->next;
	while(p)
	{
		printf(" %d \n",p->data);
		p = p->next;
	}
	return 1;
}

int main(){
	LinkQueue s;
	InitQueue(s);
	CreateQueue(s, 10);
	
//	InitQueue(s);
	PrintQueue(s);
	return 0;
}