栈和队列的操作（c）

全部在VC6.0++下实现

//顺序栈
#include
#include

#define MAXSIZE 10
typedef int datatype;
typedef struct{
	datatype data[MAXSIZE];
	int top;                //栈顶指针
}SeqStack;

//置空栈:首先建立栈空间，然后初始化栈顶指针
SeqStack* Init_SeqStack(){
	SeqStack *s;
	s=(SeqStack *)malloc(sizeof(SeqStack));
	if(s==NULL){
		printf("申请内存失败！\n");
		return NULL;
	}
	else{
		s->top=-1; //置空栈操作，栈顶指针始终指向当前栈顶元素的位置
		return s;
	}
}

//判空栈
int Empty_SeqStack(SeqStack *s){
	if(s->top== -1) //空栈标志
		return 1;
	else
		return 0;
}

//入栈
int Push_SeqStack(SeqStack *s,datatype x){
	if(s->top==MAXSIZE-1){
		printf("栈满不能入栈\n");
		return 0;      //栈满不能入栈
	}
	else{
		s->top++;
		s->data[s->top]=x;
		return 1;
	}
}

//出栈
int Pop_SeqStack(SeqStack *s,datatype *x){
	if(Empty_SeqStack(s)){
        printf("栈为空不能出栈\n");
		return 0;        //栈空不能出栈
	}
	else{
		*x=s->data[s->top]; //取栈顶值，栈顶指针始终指向当前栈顶元素的位置
		s->top--;
		return 1;
	}
}

//取栈顶元素
int Top_SeqStack(SeqStack *s,datatype *x){
	if(Empty_SeqStack(s)){//栈空
		printf("栈为空，不能取!\n");
		return 0;
	}
	else{
		*x=s->data[s->top]; //只读取栈顶元素的值，栈顶指针指针top位置保持不变
		return 1;
	}
}

//测试
int main(void){
	int i;
	int a;
	SeqStack *s;
	s=Init_SeqStack();//创建栈
	if(s==NULL)
		return 0;
	i=0;
	while(i<=MAXSIZE){
		printf("请输入元素值（整形）：");
		scanf("%d",&a);
        Push_SeqStack(s,a);
		i++;
	}
    Pop_SeqStack(s,&a);
	printf("出栈顶元素为%d\n",a);
    Top_SeqStack(s,&a);
    printf("取栈顶元素为%d\n",a);
	return 1;
}


//链栈
#include
#include
#define FALSE 0;
#define TRUE  1;

typedef int Elemtype;
typedef struct Stacknode{
	Elemtype data;
	struct Stacknode *next;
}slStacktype;

//初始化操作
slStacktype * init_Lstack(){           //创建带有头结点的链栈
	slStacktype *p;
	p=(slStacktype *)malloc(sizeof(slStacktype));
	if(p==NULL)
		printf("申请内存失败，初始化失败！\n");
	else
		p->next=NULL;
	return p;
}

//入栈操作
int push_Lstack(slStacktype *top,Elemtype x){ 
	slStacktype *p;
	p=(slStacktype*)malloc(sizeof(slStacktype));
	if(p==NULL){
		printf("申请内存失败，入栈失败！\n");
		return FALSE;
	}
	p->data=x;                 //根据栈的特点采用头插法
	p->next=top->next;
	top->next=p;
	return TRUE;
}

//出栈
int pop_Lstack(slStacktype *top,Elemtype * x){
	slStacktype *p;
	if(top->next==NULL){         //判空栈
		printf("栈为空，出栈失败!\n");
		return FALSE;
	}
	p=top->next;               //出栈
	top->next=p->next;
	*x=p->data;
	free(p);                  //释放资源
	return TRUE;
}

//打印栈中的数据
void print_Lstack(slStacktype *top){
	slStacktype *p;
	p=top->next;
	while(p!=NULL){
		printf("%d\n",p->data);
		p=p->next;
	}
}

//测试
int main(void){
	int a;
	slStacktype *top;
	top=init_Lstack();
	if(top!=NULL){
		printf("请输入，入栈值（-1结束）：");
		scanf("%d",&a);
		while(a!=-1){
           push_Lstack(top,a);
           printf("请输入，入栈值（-1结束）：");
	       scanf("%d",&a);
		}
        pop_Lstack(top,&a);
		printf("出栈值为%d\n",a);
		printf("打印栈中的元素：\n");
		print_Lstack(top);
	}
}
//两栈的共享，共享一维数组
#include
#include

#define MAXNUM 10
#define FALSE 0
#define TRUE  1

typedef int Elemtype;
typedef struct{
	Elemtype stack[MAXNUM];  //左右栈共享的数据区
	int lefttop;   //左栈栈顶指针
	int righttop;  //右栈栈顶指针
}dupsqstack;
/*
   为了识别左右栈，设置两个标志
   char status;
   status='L';   //左栈
   status='R';   //右栈
*/

//初始化操作
int init_DupStack(dupsqstack *s){
	/*
	if((s=(dupsqstack *)malloc(sizeof(dupsqstack)))==NULL){
		printf("申请内存失败！\n");
		return FALSE;
	}
	*/
	s->lefttop=-1;          //左栈空时，标志
	s->righttop=MAXNUM;    //右栈空时，标志
	return TRUE;
}

//入栈操作
int push_DupStack(dupsqstack *s,char status,Elemtype x){
	if(s->lefttop+1==s->righttop){  //栈满标志
		printf("栈满不能入栈！\n");
		return FALSE;
	}
	if(status=='L'){
        s->lefttop++;
		s->stack[s->lefttop]=x;    //++左栈进栈
	}
	else if(status=='R'){
		    s->righttop--;
		    s->stack[s->righttop]=x; //--右栈进栈
	}
	else{
		printf("输入符号有误，入栈失败！\n");
		return FALSE;
	}
	return TRUE;
}

//出栈操作
int pop_DupStack(dupsqstack *s,char status,Elemtype *x){
	//先判断栈是出那个栈元素，再进行出栈操作
	if(status=='L'){                          //左栈
		if(s->lefttop<0){
			printf("左栈为空，出栈失败！\n");
		    return FALSE;
		}
		else{
			*x=s->stack[s->lefttop];   //取栈顶元素
			s->lefttop--;              //改变栈顶指针--
			return TRUE;
		}
	}
	else if(status=='R'){                    //右栈
		if(s->righttop>MAXNUM-1){
			printf("右栈为空，出栈失败！\n");
			return FALSE;
		}
		else{
			*x=s->stack[s->righttop];  //取栈顶元素
			s->righttop++;             //改变栈顶指针++
			return TRUE;
		}
	}
	else{
		printf("选择栈有问题，出栈失败!");
		return FALSE;
	}
}


//测试
int main(void){
   int i;
   dupsqstack s;
   char st;
   int x;
   init_DupStack(&s);
   i=0;
   while(i<=MAXNUM){
	   printf("请选择栈（R或L）：");
	   scanf("%c",&st);
	   printf("请输入入栈值：");
	   scanf("%d",&x);
       fflush(stdin);             //清除标准输入设备（即键盘）的缓冲区。
       push_DupStack(&s,st, x);
	   i++;
   }
   printf("出栈，请选择栈（R或L）：");
   scanf("%c",&st);
   pop_DupStack(&s,st,&x);
   printf("出栈值为%d\n",x);
   fflush(stdin);
   printf("出栈，请选择栈（R或L）：");
   scanf("%c",&st);
   pop_DupStack(&s,st,&x);
   printf("出栈值为%d\n",x);
}

//用数组保存所有链栈的栈顶指针，访问链栈时要提供对应链栈的下标
#define FALSE 0;
#define TRUE  1;
#define M  10;
typedef int Elemtype;
typedef struct Stacknode{
	Elemtype data;
	struct Stacknode *next;
}slStacktype;

//将栈顶指针放在一个一维数组中，统一管理
//slStacktype *top[M];

//入栈操作
int push_Lstack(slStacktype *top[],int i,Elemtype x){
	//将元素x压入链栈top[i]中
	slStacktype *p;
	p=(slStacktype*)malloc(sizeof(slStacktype));
	if(p==NULL){
		printf("申请内存失败，入栈失败！\n");
		return FALSE;
	}
	p->data=x;                 //根据栈的特点采用头插法
	p->next=top[i]->next;
	top[i]->next=p;
	return TRUE;
}

//出栈
int pop_Lstack(slStacktype *top[],int i,Elemtype * x){
	//从链栈top[i]中删除栈顶元素
	slStacktype *p;
	if(top[i]->next==NULL){         //判空栈
		printf("栈为空，出栈失败!\n");
		return FALSE;
	}
	p=top[i]->next;               //出栈
	top[i]->next=p->next;
	*x=p->data;
	free(p);                  //释放资源
	return TRUE;
}

//顺序队列
#include
#include

#define MAXSIZE 10

typedef int datatype;
typedef struct{
	datatype data[MAXSIZE];
	int front; //队头指示器，总是指向队头元素的前一个位置
	int rear; //队尾指示器，总是指向队尾元素
}SeQueue;

//初始化队列
SeQueue* Init_Queue(){
	SeQueue *p;
	p=(SeQueue*)malloc(sizeof(SeQueue));
	if(p==NULL)
		printf("初始化失败！\n");
	else{
		p->front=-1;  //初始化
		p->rear=-1;
	}
	return p;
}
//不考虑溢出情况下入队
void In_Queue(SeQueue *p,datatype x){
	p->rear++;
	p->data[p->rear]=x;
}
//不考虑空队情况下出队
void  Out_Queue(SeQueue *p,datatype *x){
	p->front++;
	*x=p->data[p->front];
}
//循环队列---规定顺序队列最后一个单元的后继为第一个单元
#include
#include

#define MAXSIZE 10       //循环队列中最多存储MAXSIZE-1个元素
#define FALSE  0
#define TRUE  1
typedef int datatype;
typedef struct{
	datatype data[MAXSIZE];
	int front; //队头指示器，总是指向队头元素的前一个位置
	int rear; //队尾指示器，总是指向队尾元素
}CSeQueue;

//置空队
CSeQueue* Init_SeQueue(){
	CSeQueue *p;
	p=(CSeQueue *)malloc(sizeof(CSeQueue));
	if(p==NULL)
		printf("置空队失败！！！\n");
	else{
		p->front=MAXSIZE-1;      //置空队条件
	    p->rear=MAXSIZE-1;
	}
	return p;
}

//入队
int In_SeQueue(CSeQueue *q,datatype x){
	if((q->rear+1)%MAXSIZE==q->front){   //队满条件
		printf("队满，不能入队\n");
		return FALSE;
	}
	else{
		q->rear=(q->rear+1)%MAXSIZE;            //入对条件
		q->data[q->rear]=x;
		return TRUE;
	}
}

//出队
int Out_SeQueue(CSeQueue *q,datatype *x){
	if(q->front==q->rear){   //空队条件
		printf("队空，不能出队!\n");
		return FALSE;
	}
	else{
		q->front=(q->front+1)%MAXSIZE;  //出队条件
		*x=q->data[q->front];           //读出队头元素
		return TRUE; 
	}
}

//判队空
int Empty_SeQueue(CSeQueue *q){
	if(q->front==q->rear)
		return TRUE;
	else
		return FALSE;
}

// 读队头元素
int Front_SeQueue(CSeQueue *p,datatype *x){
	int k;
	if(Empty_SeQueue(p)){
		printf("队空\n");
		return FALSE;
	}
	else{
        k=p->front;
		k=(k+1)%MAXSIZE;
		*x=p->data[k];
		return TRUE;
	}
}

//测试
int main(void){
	int i;
	int x;
	CSeQueue *q;
	q=Init_SeQueue();
	if(q==NULL)
		return 0;
	else{
		printf("判断队是否为空1:%d\n",Empty_SeQueue(q));
		i=0;
		while(i
#include

#define TRUE  1
#define FALSE 0

typedef int datatype;
//链队列的数据类型描述
typedef struct node{
	datatype data;
	struct node *next;
}QNode;                      //链队列结点的描述
typedef struct {
	QNode *front; //队头指针
	QNode *rear;  //队尾指针
}LQueue;

//创建一个带头结点的空队
LQueue * Init_LQueue(){
	LQueue *q;
	QNode *p;
	q=(LQueue *)malloc(sizeof(LQueue));//申请头尾指针结点
	p=(QNode *)malloc(sizeof(QNode)); //申请链队头结点
	if(p==NULL || q==NULL)
		printf("创建失败！！\n");
	else{
		p->next=NULL;
		q->front=q->rear=p; //置空队，指向头结点
	}
	return q;
}

//入队
int IN_LQueue(LQueue *q,datatype x){
	QNode *p;
	p=(QNode *)malloc(sizeof(QNode));
	if(p==NULL){
	  printf("入队申请内存失败！\n");
	  return FALSE;
	}
	else{
		p->data=x;
		p->next=NULL;      //因为在队尾所以置为NULL
		q->rear->next=p;  //将p链接到队尾
		q->rear=p;       //改变队尾指针
	    return TRUE;
	}
}

//判队空
int Empty_LQueue(LQueue *q){
	if(q->front==q->rear) //空队条件
		return TRUE;
	else
		return FALSE;
}

//出队
int Out_LQueue(LQueue *q,datatype *x){
	QNode *p;
	if(Empty_LQueue(q)){
		printf("空队！！\n");
		return FALSE;
	}
	else{
		p=q->front->next;         //带头结点的队
		q->front->next=p->next;
		*x=p->data;
		free(p);
		if(q->front->next==NULL) //只有一个元素时，出队后为空，修改队尾指针
			q->rear=q->front;
		return TRUE;
	}
}

//打印队列中的元素
int  print_LQueue(LQueue *q){
	QNode *p;
    if(Empty_LQueue(q)){
		printf("空队！！\n");
		return FALSE;
	}
	else{
		p=q->front->next;
		while(p!=NULL){
			printf("%d\n",p->data);
			p=p->next;
		}
		return TRUE;
	}

}

//测试
int main(void){
	int x;
	LQueue *q;
	q=Init_LQueue();
	if(q==NULL)
		return 0;
	else{
		printf("判断队是否为空%d\n",Empty_LQueue(q));
		printf("请输入入队值（整形-1结束）：");
		scanf("%d",&x);
		while(x!=-1){
           IN_LQueue(q, x);
           printf("请输入入队值（整形-1结束）：");
	       scanf("%d",&x);
		}
        printf("判断队是否为空%d\n",Empty_LQueue(q));
		Out_LQueue(q,&x);
		printf("出队元素%d\n",x);
       print_LQueue(q);
		return 1;
	}
}