第二章——堆栈、队列

再度回顾基础内容。为数据结构打下扎实基础。

---

实验内容：

1.编写函数，采用链式存储实现栈的初始化、入栈、出栈操作。

2.编写函数，采用顺序存储实现栈的初始化、入栈、出栈操作。

3.编写函数，采用链式存储实现队列的初始化、入队、出队操作。

4.编写函数，采用顺序存储实现队列的初始化、入队、出队操作。

堆栈：

 链式版的在入栈之前要先判断头指针是否为空，如果为空则创建一个链表，并且将尾指针和头指针指向同一个位置；若不为空则在表尾插入新数据，让尾指针更新位置即可；

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 1000
//链表 
typedef struct node{
	int Data;
	struct node *next;	
}Linklist;
typedef struct{
	Linklist *List;//链表
	Linklist *top; //Top栈顶	
}Stack_Link;//链式堆栈 先入后出 
typedef struct{
	int Array[MAXSIZE];
	int top;//堆栈头 
}Stack_Array;//顺序表堆栈 
Linklist *Create(int value);//链表的建立 
void LoadStack_Link(Stack_Link *S);//链式堆栈初始化 
void PushStack_Link(Stack_Link *S,int value);//链式堆栈入栈 
int PopStack_Link(Stack_Link *S);//链式堆栈出栈 
void LoadStack_Array(Stack_Array *S);//顺序堆栈初始化 
void PushStack_Array(Stack_Array *S,int value);//顺序堆栈入栈 
int PopStack_Array(Stack_Array *S);//顺序堆栈出栈 
void Menu1();
void Menu2();
void Menu();

int main(){
	
	Menu();

	return 0;
}
Linklist *Create(int value)
{
	Linklist *head,*node,*tail,*Thead;
	head=tail=NULL;	
	node=(Linklist*)malloc(sizeof(Linklist));
	node->Data=value;
	node->next=NULL;
	if(head==NULL){
		head=node;
	}
	else {
		tail->next=node;
	}
	tail=node;
	
	return head;
}

//编写函数 采用链式存储实现栈的初始化 入栈 出栈操作
void LoadStack_Link(Stack_Link *S){
	//链表堆栈初始化
	 S->List=S->top=NULL;
	 printf("链式堆栈初始化成功!\n");
}
void PushStack_Link(Stack_Link *S,int value){
	//链表堆栈入栈
	//相当于从链表表尾插入数据
	if(S->List==NULL){
		//创建链表
		S->List=Create(value);
		S->top=S->List;
	}
	//表尾插入法 
	else {
		 Linklist *t=S->List;
		 while(t->next){
		 	t=t->next;
		 }
		 Linklist *node;
		 node=(Linklist*)malloc(sizeof(Linklist));
		 node->Data=value;
		 node->next=NULL;
		 t->next=node;
		 S->top=t->next;
	}
	printf("链式堆栈入栈成功!\n"); 
}
int PopStack_Link(Stack_Link *S){
	if(S->List==NULL){
		printf("该堆栈已空!\n");
		return -1;
	}
	int x=S->top->Data;
	Linklist *t=S->List,*node;
	if(t->next){
		while(t->next->next){
		t=t->next;
	}
	//说明是倒数第二个 
	node=t->next;
	t->next=NULL;	
	}	
	else{
		//说明堆栈里面只剩下一个数据,需要把头节点也置空 
		node=t;
		t=NULL;
		S->List=t;
	}	
	free(node);
	S->top=t;
	printf("链式堆栈出栈成功!\n");
	return x;
}

//顺序存储 采用顺序存储实现栈的初始化 入栈 出栈操作
void LoadStack_Array(Stack_Array *S){
	//顺序堆栈初始化
	 S->top=-1;
//	 S->Array=NULL;
	 printf("顺序堆栈初始化成功!\n");
}
void PushStack_Array(Stack_Array *S,int value){
	//顺序堆栈入栈
	S->Array[++S->top]=value;
	printf("顺序堆栈入栈成功!\n"); 
}
int PopStack_Array(Stack_Array *S){
	if(S->top<=-1){
		printf("该顺序堆栈已空!\n");
		return -1;
	}
	int x=S->Array[S->top];
	S->top--;
	printf("顺序堆出栈成功!\n");
	return x;
}


//菜单函数 
void Menu1(){ 
	int ret;
	int FLAG=1;
	Stack_Array S;
	while(FLAG){
		printf("输入1对顺序表堆栈初始化\n");
		printf("输入2对顺序表堆栈入栈,并输入入栈的数据\n");
		printf("输入3对顺序表堆栈出栈,我会返回该出栈数据\n");
		printf("输入4对顺序表堆栈进行遍历\n");
		printf("输入-1退出\n");
		scanf("%d",&ret);
	switch(ret){
		case 1:
			LoadStack_Array(&S);
			break;
		case 2:
			printf("请输入入栈数据\n");
			int value;
			scanf("%d",&value);
			PushStack_Array(&S,value);
			break;
		case 3:
			int a;
			a=PopStack_Array(&S);
			printf("出栈数据为:%d\n",a);
			break;
		case 4:
			int i;
			printf("堆栈的数据是:\n***");
			for(i=0;i<=S.top;i++){
				printf("%d ",S.Array[i]);
			}
			printf("\n***\n");
			break;
		case -1:
			FLAG=0;
			break;
	}
	}
}
void Menu2(){ 
	int ret;
	int FLAG=1;
	Stack_Link S;
	while(FLAG){
		printf("输入1对链表堆栈初始化\n");
		printf("输入2对链表堆栈入栈,并输入入栈的数据\n");
		printf("输入3对链表堆栈出栈,我会返回该出栈数据\n");
		printf("输入4对链表堆栈遍历\n");
		printf("输入-1退出\n");
		scanf("%d",&ret);
	switch(ret){
		case 1:
			LoadStack_Link(&S);
			break;
		case 2:
			printf("请输入入栈数据\n");
			int value;
			scanf("%d",&value);
			PushStack_Link(&S,value);
			break;
		case 3:
			int a;
			a=PopStack_Link(&S);
			printf("出栈数据为:%d\n",a);
			break;
		case 4:
			{
			Linklist *t=S.List;
			printf("***\n");
			while(t){
				printf("%d ",t->Data);
				t=t->next;
			}
			printf("\n***\n");
			break;
			}
		case -1:
			FLAG=0;
			break;
	}
	}
}
void Menu(){
	printf("输入1进行对顺序表堆栈的操作\n");
	printf("输入2进行对链表堆栈的操作\n");
	int ret;
	scanf("%d",&ret);
	switch(ret){
		case 1:
			Menu1();
			break;
		case 2:
			Menu2();
			break;
		case 0: 
			break;
	}
}

队列：

顺序版队列：

#include<stdio.h>
#include<stdlib.h>
//顺序版队列
#define MAXSIZE 1000
typedef struct{
 int data[MAXSIZE];    
    int head;//头结点
    int tail;//尾巴结点
    
}ListQueue;
void LoadListQueue(ListQueue *q){
  q->head=q->tail=0;
     printf("顺序队列初始化成功!\n");   
}
void PushListQueue(ListQueue *q,int value){
    int t=q->tail;
    q->tail=(q->tail+1)%MAXSIZE;//为了循环
  q->data[t]=value;
     printf("插入成功!\n");   
}
int popListQueue(ListQueue *q){
    int t=q->head;
    q->head=(q->head+1)%MAXSIZE;

    return q->data[t];   
}
int main()
{ 
    //编写函数，采用顺序存储实现队列的初始化、入队、出队操作
    ListQueue Q;
    int ret,FLAG=1;
    while(FLAG){
        
    printf("输入1初始化队列\n");
    printf("输入2入队列\n");
    printf("输入3出队列\n");
    printf("输入4退出\n");
    scanf("%d",&ret);
    
        switch(ret){
     case 1:{
       LoadListQueue(&Q);
                printf("LoadQueueOK!");
                break;
                }
        case 2:
          {
             int value;
          printf("请输入插入的数据\n");
                scanf("%d",&value);
       PushListQueue(&Q,value);
        break;
                 }
        case 3:
          {
          int value;
          value=popListQueue(&Q);  
                printf("出队成功！数据为:%d\n",value);    
                break;
                }      
        case 4:
          {
          FLAG=0;
                break;
                }
    }
    
    }
}

 链表版：

#include<stdio.h>
#include<stdlib.h>
typedef struct node{
    int data;
    //数据域
    struct node *next;
    //指针域
}LinkList;
typedef struct queue{
    //只需要头尾指针
 LinkList *head;
    LinkList *tail;(
}LinkQueue;
void LoadLinkQueue(LinkQueue *q);
void PushLinkQueue(LinkQueue *q,int value);
int popLinkQueue(LinkQueue *q);
int main(){
 
 LinkQueue q;
    LoadLinkQueue(&q);
    
    
    PushLinkQueue(&q,1);
    PushLinkQueue(&q,2);
    PushLinkQueue(&q,3);
    PushLinkQueue(&q,4);
    
    printf("%d ",popLinkQueue(&q));
    printf("%d ",popLinkQueue(&q));
    printf("%d ",popLinkQueue(&q));
    printf("%d ",popLinkQueue(&q));
    printf("%d ",popLinkQueue(&q));
    return 0;
}

 void LoadLinkQueue(LinkQueue *q){
 q->head=q->tail=NULL;
    printf("初始化成功!\n");    
}
void PushLinkQueue(LinkQueue *q,int value){
 if(q->head==NULL){
        //当头指针也为空时,建立链表
     q->head=(LinkList*)malloc(sizeof(LinkList));
        q->head->data=value;
        q->head->next=NULL;
        q->tail=q->head;
    }
    else {
     //头指针不变,往尾指针插入新数据
        LinkList *t=q->tail;
        while(t->next){
         t=t->next;
        }
        LinkList *node=(LinkList*)malloc(sizeof(LinkList));
        node->data=value;
        node->next=NULL;//创建一个新结点
        t->next=node;
        q->tail=node;//更新队尾的指向
    }
    printf("插入成功!\n");
}
int popLinkQueue(LinkQueue *q){
  if(q->head==NULL){
            printf("当前队列为空!\n");
         return -1;
        }
        else {
         int value=q->head->data;
            LinkList *t=q->head;
            q->head=t->next;//移动头指针位置
            free(t);
            printf("出队成功!\n");
            return value;
            
        }

}