栈的一般操作和循环队列的一般操作

最近又开始有些松懈了，还好今天算是好好的学了一段时间。希望自己坚持下去，加油！

小码农的生活是无趣的。还好还有朋友，今天和朋友吃了火锅，大连的虾仁真的好好吃！  

ShanSir@Dalian 2012_4_8

贴两个小程序，关于栈的一般操作和循环链表的一般操作。

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

typedef struct Node
{
	int data;
	struct Node* pNext;
}NODE,*PNODE;

typedef struct Stack
{
	PNODE pTop;    
	PNODE pBottom;
}STACK,*PSTACK; //PSTACK 等价于 struct STACK *

void init(PSTACK);
void push(PSTACK ,int);
void traverse(PSTACK);
bool pop(PSTACK,int *);

int main()
{
	STACK S; //STACK 等价于struct Stack;
	int val;

	init(&S);  //目的是造出一个空栈
	push(&S,1);//压栈
	push(&S,2);
	push(&S,3);
	printf("压栈后输出");
	traverse(&S);//遍历输出
	printf("\n");

	
	pop(&S,&val);//退栈
	printf("退栈后输出");
	traverse(&S);//遍历输出
	printf("\n");

	return 0;
}

void init(PSTACK pS )
{
	pS->pTop = (PNODE)malloc(sizeof(NODE));
	if(NULL == pS->pTop)
	{
		printf("动态内存分配失败！\n");
		exit(-1);
	}
	else
	{
		pS->pBottom = pS->pTop;
		pS->pBottom->pNext = NULL;
	}
}

void push(PSTACK pS,int val)
{
	PNODE pNew = (PNODE)malloc(sizeof(NODE));

	pNew -> data = val;
	pNew -> pNext = pS->pTop; //pS->Top 不能为ps->Bottom
	pS ->pTop = pNew;

	return;
}

void traverse(PSTACK pS)
{
	PNODE p = pS->pTop;
	while(p != pS->pBottom)
	{
		printf("%d",p->data);
		p = p->pNext;
	}
	printf("\n");

	return;
}

bool empty(PSTACK pS)
{
	if(pS->pTop == pS->pBottom)
		return true;
	else
		return false;
}
//把pS所指向的栈出栈一次，并把出栈的元素存入pVal形参
bool pop(PSTACK pS,int *pVal)
{
	if(empty(pS)) //pS本身存放的就是S的地址
	{
		return false;
	}
	else
	{
		PNODE r = pS->pTop;
		*pVal = r->data;
		pS->pTop = r->pNext;
		free(r);
		r = NULL;

		return true;
	}
}



void clear()
{
	if(empty)
	{
		return ;
	}
	else
	{
		PNODE p = pS -> pTop;
		PNODE q = p ->pNext;
		
		while(pS->pTop != pS->pBottom)
		{
			q = p->pNext;
			free(p);
			p = q;
		}
		pS->pTop = pS->pBottom;
	}
}












//循环队列
#include <stdio.h>
#include <stdlib.h>

typedef struct Queue
{
	int *pBase;
	int front;
	int rear;
}QUEUE;

void init(QUEUE *);
bool en_queue(QUEUE *,int val);
void traverse_queue(QUEUE *);
bool full_queue(QUEUE *);
bool out_queue(QUEUE *,int *);
bool emput_queue(QUEUE *);


int main()
{
	Queue Q;
	init(&Q);
	int val;

	//压入循环队列的操作，把1,2,3分别压入循环队列
	en_queue(&Q,1);
	en_queue(&Q,2);
	en_queue(&Q,3);
	//遍历循环队列
	traverse_queue(&Q);
	printf("\n");
	
	//从循环队列中弹出元素
	out_queue(&Q,&val);
	//遍历循环队列
	traverse_queue(&Q);
	printf(n");

	//显示从循环队列中弹出元素的值
	printf("%d\n",val);
}

void init(QUEUE *pQ)
{
	pQ->pBase = (int *)malloc(sizeof(int) * 6);
	pQ->front = 0;
	pQ->rear = 0;
}

bool en_queue(QUEUE *pQ,int val)
{
	if(full_queue(pQ))
	{
		return false;
	}
	else
	{
		pQ->pBase[pQ->rear] = val;
		pQ->rear = (pQ->rear) % 6 + 1;

		return true;
	}
}

bool full_queue(QUEUE *pQ)
{
	if((pQ->rear + 1) % 6 == pQ->front)
		return true;
	else
		return false;
}

void traverse_queue(QUEUE *pQ)
{
	int i = pQ->front;
	while(i != pQ->rear)
	{
		printf("%d",pQ->pBase[i]);
		i = (i+1) % 6;
	}
	return;
}
bool empty_queue(QUEUE *pQ)
{
	if(pQ->front == pQ->rear)
	{
		return true;
	}
	else
	{
		return false;
	}
}
bool out_queue(QUEUE *pQ,int *pVal)
{
	if(empty_queue(pQ))
	{
		return false;
	}
	else
	{
		*pVal = pQ->pBase[pQ->front];
		pQ->front = (pQ->front+1) % 6;

		return true;
	}
}
*/