数据结构之栈和队列

四，顺序栈和顺序队列

（1）顺序栈的应用（十进制数转换为二进制数）

#include<stdio.h>
#include<stdlib.h>
#define ElemType int 
#define max 100
#define N 2
typedef struct
{
	ElemType data[max];
	int top;
}sqstack;
sqstack *s;
void initstack(sqstack *&s)
{
	s=(sqstack *)malloc(sizeof(sqstack));
	s->top=-1;
}
bool push(sqstack *&s,ElemType e)
{
	if(s->top==max-1)
		return false;
	s->top++;
	s->data[s->top]=e;
	return true;
}
bool pop(sqstack *&s,ElemType &e)
{
	if(s->top==-1)
		return false;
	e=s->data[s->top];
	s->top--;
	printf("%d",e);
	return true;
}
void dub(int x)
{
	
	int m,n,y;
	while(x>0)
	{
		m=x%N;
		x=x/N;
		push(s,m);
	}
	while(s->top!=-1)
	{	
		pop(s,n);
	}
}
int main()
{
	int x;
	initstack(s);
	printf("请输入一个十进制数\n");
	scanf("%d",&x);
	dub(x);
	printf("\n");
	system("pause");
	return 0;
}

（2）顺序队列的应用

#include<stdio.h>
#include<stdlib.h>
#define ElemType int 
#define max 100
typedef struct 
{
	ElemType data[max];
	int front,rear;
}squeue;
squeue *q;
void initqueue(squeue *&q)
{
	q=(squeue *)malloc(sizeof(squeue));
	q->front=q->rear=-1;
} 
bool queueempty(squeue *q) 
{
	return(q->front==q->rear);
}
bool enqueue(squeue *&q,ElemType e)
{
	if(q->rear==max-1)
		return false;
	q->rear++;
	q->data[q->rear]=e;
	return true;
}
bool dequeue(squeue *&q,ElemType &e)
{
	if(q->front==q->rear)
		return false;
	q->front++;
	e=q->data[q->front];
	
	return true;
}
void paidui(int x)
{
	int i,n;
	printf("原始数据为：\n");
	for(i=1;i<=x;i++)
	{
		enqueue(q,i);
		dequeue(q,n);
		printf("%d    ",n);
	}
	printf("\n出队顺序：\n");
	for(i=1;i<=x;i++)
	{
		enqueue(q,i);
	}
	while(queueempty(q)!=true)
	{
		dequeue(q,n);
		printf("%d    ",n);
		if(queueempty(q)!=true)
		{
			dequeue(q,n);
			enqueue(q,n);
		}
	}
}
int main()
{
	initqueue(q);
	int x;
	printf("请输入数字：\n");
	scanf("%d",&x);
	paidui(x);
	printf("\n");
	system("pause");
	return 0;
}

五，实现链栈的基本运算的算法

#include<stdio.h>
#include<stdlib.h>
#define ElemType int
typedef struct linknode
{
	ElemType data;
	struct linknode *next;
}LinkStNode;

void initlist(LinkStNode *&s) //初始化栈
{
	s = (LinkStNode *)malloc(sizeof(LinkStNode));//头节点
	s->next = NULL;
}

void destorylist(LinkStNode *&s) //销毁栈
{
	LinkStNode *pre = s, *p = s->next;          //p指向首节点
	while (p != NULL)
	{
		free(pre);
		pre = p;
		p = pre->next;   //pre和p同时向后移 
	}
	free(pre);
}

bool stackempty(LinkStNode *s)   //判断栈是否为空
{
	return(s->next == NULL);
}

void push(LinkStNode *&s, ElemType m)   //进栈
{
	LinkStNode *p;
	p = (LinkStNode *)malloc(sizeof(LinkStNode));//新建节点
	p->data = m;
	p->next = s->next;       //头插
	s->next = p;
	printf("%d\n",s->next->data );
}

bool pop(LinkStNode *&s, ElemType &m)      //出栈
{
	LinkStNode *p;
	if (s->next == NULL)
	{
		return false;
	}
	p = s->next;     //p指向首节点
	m = p->data;
	s->next = p->next;     //删除首节点
	free(p);
	return true;
}
bool gettop(LinkStNode *s, ElemType &m)  //取栈顶元素
{
	if (s->next == NULL)
	{
		return false;
	}
	m = s->next->data;
	return true;
}
int main()
{
	LinkStNode *p;
	ElemType n;
	initlist(p);
	printf("入栈后为：\n");
	push(p, 10);
	push(p, 20);
	push(p, 30);
	push(p, 40);
	push(p, 50);
	printf("\n出栈后为：\n");
	pop(p, n);
	printf("%d\n", n);
	pop(p, n);
	printf("%d\n", n);
	pop(p, n);
	printf("%d\n", n);
	pop(p, n);
	printf("%d\n", n);
	pop(p, n);
	printf("%d\n", n);
	system("pause");
	return 0;
}

六，实现链队的基本运算的算法

#include<stdio.h>
#include<stdlib.h>
#define ElemType int
typedef struct qnode
{
	ElemType data;
	struct qnode *next;
}DataNode;             //链据数据节点的类型
typedef struct queue
{
	DataNode *front;
	DataNode *rear;
}Linkqueue;           //链队结点的类型
void initqueue(Linkqueue *&s)  //初始化
{
	s = (Linkqueue *)malloc(sizeof(Linkqueue));
	s->front = s->rear = NULL;
}
void Destoryqueue(Linkqueue *&s)    //销毁队列
{
	DataNode *pre = s->front, *p;      //pre指向首节点
	if (pre != NULL)
	{
		p = pre->next;
		while (p != NULL)
		{
			free(pre);
			pre = p;       //同步向后移
			p = p->next;
		}
		free(pre);         //释放最后一个数据节点
	}
	free(s);          //释放链队结点
}
bool Queueempty(Linkqueue *&s)      //判空
{
	return(s->rear == s->front);
}
void enqueue(Linkqueue *&s, ElemType e)   //进队列
{
	DataNode *p;
	p = (DataNode *)malloc(sizeof(DataNode));
	p->data = e;
	p->next = NULL;
	if (s->rear == NULL)
	{
		s->front = s->rear = p;
	}
	else
	{
		s->rear->next = p;      //尾插
		s->rear = p;
	}
}
bool dequeue(Linkqueue *&s, ElemType &e)   //出队列
{
	DataNode *t;
	if (s->rear == NULL)
		return false;
	t = s->front;
	if (s->front == s->rear)
		s->front = s->rear = NULL;
	else
		s->front = s->front->next;
	e = t->data;
	free(t); 
	return true;
}
int main()
{
	Linkqueue *s;
	ElemType n;
	initqueue(s);
	enqueue(s, 10);
	enqueue(s, 20);
	enqueue(s, 30);
	enqueue(s, 40);
	enqueue(s, 50);
	printf("出队列为：\n");
	dequeue(s, n);
	printf("%d\n", n);
	dequeue(s, n);
	printf("%d\n", n);
	dequeue(s, n);
	printf("%d\n", n);
	dequeue(s, n);
	printf("%d\n", n);
	dequeue(s, n);
	printf("%d\n", n);
	system("pause");
	return 0;
}

七，实现环形队列的基本运算的算法

#include<stdio.h>
#include<stdlib.h>
#define ElemType int
#define max 6
typedef struct queue
{
	ElemType data[max];
	int front;
	int rear;
}Squeue;
void initqueue(Squeue *&s)   //初始化
{
	s = (Squeue *)malloc(sizeof(Squeue));
	s->front = s->rear = 0;
}
void Destoryqueue(Squeue *&s)    //销毁队列
{
	free(s);
}
bool queueempty(Squeue *s)    //判空
{
	return(s->front == s->rear);
}
bool enqueue(Squeue *s, ElemType m)    //进队列
{
	if ((s->rear + 1) % max == s->front)      //判断队满
		return false;
	s->rear = (s->rear + 1) % max;
	s->data[s->rear] = m;
	printf("%d\n", s->data[s->rear]);
	return true;
}
bool dequeue(Squeue *&s, ElemType &m)   //出队列
{
	if (s->front == s->rear)        //队空
		return false;
	else
	{
		s->front = (s->front + 1) % max;
		m = s->data[s->front];
		return true;
	}
}
int main()
{
	Squeue *p;
	ElemType n;
	initqueue(p);
	enqueue(p, 10);
	enqueue(p, 20);
	enqueue(p, 30);
	enqueue(p, 40);
	enqueue(p, 50);
	printf("出队列为：\n");
	dequeue(p, n);
	printf("%d\n", n);
	dequeue(p, n);
	printf("%d\n", n);
	dequeue(p, n);
	printf("%d\n", n);
	dequeue(p, n);
	printf("%d\n", n);
	dequeue(p, n);
	printf("%d\n", n);
	system("pause");
	return 0;
}