数据结构--栈，队列

一，栈

          1>栈：只允许在表尾进行插入和操作受限的线性表

           2>逻辑结构：线性结构【一对一】

           3>存储结构：顺序存储【顺序栈】，链式存储【链栈】

           4>特点：先进后出

                          后进先出

           5>栈顶int top：最顶部元素的下标

           6栈空：top=-1;

              栈满：top=MAXSIZE-1

1.1顺序栈

顺序栈：栈的顺序存储结构

顺序栈的结构体定义：数据元素，栈顶

typedef struct

{

         //数据元素

        int data[MAXSIZE];

        //栈顶：最顶部元素的下标

        int top;

}stack;

3.入栈顺序ABC，可以一边入栈一边出栈，问出栈顺序有几种？

1.2顺序栈操作

1.栈在堆区空间的申请

2.栈的插入

3.栈的删除

4.栈的遍历

1.3链栈的操作

顺序栈是借助于数组实现的，但是顺序栈存在栈满，适用于数据量较小的情况

所以引出链栈，链栈是采用链式存储实现，最大优点没有栈满，适用于数据量较大的情况

栈的插入和删除等价于头插头删

头插头删：单链表的头结点等价于栈的栈顶

尾插尾删：单链表的尾结点等价于栈的栈顶

#ifndef __HEAD_H
#define __HEAD_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXSIZE 10
typedef int datatype;
typedef struct
{
	datatype data[MAXSIZE];
	int top;
}stack;
stack *create_list();
//===================

typedef struct Node
{
	union{
	datatype data;
	int len;
	};
	struct Node *next;
}*link_stack;
link_stack create_node(int flag);
void link_output(link_stack L);
int delete_head(link_stack L);





#endif
#include "head.h"
int main(int argc,const char *argv[])
{  

	int number;
	while(1)
	{
	puts("***************");
	puts("\t 1.顺序栈");
	puts("\t 2..链栈");
	puts("\t 3.exit");
	puts("***************");
	printf("please choose function number\n");
	scanf("%d",&number);
	switch(number)
	{
	case 1:
			menue2();
			break;
	case 2:
		
			menue3();
			break;
	case 0:
			exit(0);

	default:printf(" the number is wrong!\n");
					break;

	}

	return 0;
}
}
#include "head.h"
void menue2()
{
	stack *list=create_list();
	puts("***************");
	puts("\t 1.顺序栈插入");
	puts("\t 2.顺序栈删除");
	puts("\t 3.顺序栈遍历");
	puts("\t 0.return prev");
	puts("***************");
		while(1)
		{
	       int number;
			printf("please choose function number\n");
			scanf("%d",&number);
			switch(number)
			{
			case 1:
				{
					int n,i;
					datatype e;
					puts("插入个数");
					scanf("%d",&n);
					for(i=0;i<n;i++)
					{
						printf("第%d入栈的值\n",i+1);
						scanf("%d",&e);
						push(list,e);
						
					}
				}
				break;
			case 2:
				pop(list);
				break;
			case 3:
				output(list);
				break;
			default:printf(" the number is wrong!\n");
					break;
			case 0:
			  puts("return prev");
				return;
			}
		}

}
void menue3()
{
	link_stack list=create_node(1);
	puts("***************");
	puts("\t 1.链栈插入");
	puts("\t 2.链栈删除");
	puts("\t 3.链栈遍历");
	puts("\t 0.return prev");
	puts("***************");
	while(1)
		{
	       int number;
			printf("please choose function number\n");
			scanf("%d",&number);
			switch(number)
			{
			case 1:
				{
					int n,i;
					datatype e;
					puts("插入个数");
					scanf("%d",&n);
					for(i=0;i<n;i++)
					{
						printf("第%d入栈的值\n",i+1);
						scanf("%d",&e);
						insert_head(list,e);
						
					}
				}
				break;
			case 2:
				delete_head(list);
				break;
			case 3:
				link_output(list);
				break;
			default:printf(" the number is wrong!\n");
					break;
			case 0:
			  puts("return prev");
				return;
			}
		}

}




stack *create_list()
{
	stack *list=(stack *)malloc(sizeof(stack));
	if(list==NULL)
		return NULL;
	list->top=-1;
	return list;
}
int push(stack *list,datatype e)
{
	if(list==NULL||list->top==MAXSIZE-1)
	{
		puts("push defeat!");
		return -1;
	}
	list->data[++list->top]=e;
	return 0;
}
int pop(stack *list)
{
	if(list==NULL||list->top==-1)
	{
		puts("out  defeat!");
		return -1;
	}
	printf("the out number is %d\n",list->data[list->top]);
	list->top--;

}
int output(stack *list)
{
	if(list==NULL||list->top==-1)
	{
		puts("output  defeat!");
		return -1;
	}

	int i=0;
	for(i=0;i<=list->top;i++)
		printf("%d\t",list->data[i]);
	puts("");
	return 0;

}
link_stack create_node(int flag)
{
	link_stack L=(link_stack)malloc(sizeof(struct Node));
	if(L==NULL)
		return NULL;
	if(flag==1)
		L->len=0;
	else if(flag==0)
	{
		L->data=0;
	}
	L->next=NULL;
	return L;
}
int insert_head(link_stack L,datatype e)
{
	if(L==NULL)
	{
		puts("defeat!");
		return -1;
	}
	link_stack s=create_node(0);
	if(s==NULL)
		return -1;
	s->data=e;
	s->next=L->next;
	L->next=s;
	L->len++;
	puts("insert scuccess!");
	return 0;

}
int delete_head(link_stack L)
{
	if(L==NULL||L->next==NULL)
		return -1;
	link_stack s=L->next;
	printf("the delete number is %d\n",s->data);
	L->next=s->next;
	free(s);
	s=NULL;
	L->len--;
	puts("delete success!");
	return 0;

}
void link_output(link_stack L)
{
	link_stack p=L;
	while(p->next!=NULL)
	{
		p=p->next;
		printf("the number is %d\n",p->data);
	}
}

二，队列

队列：只允许在表尾插入，表头删除操作受限的线性表

逻辑结构：线性结构

存储结构：顺序存储，链式存存储

队列特点：先进先出【FIFO表】后进后出【LILO表】

队头和队尾

队头：第一个元素的下标

队尾：元素个数

顺序队列队满条件rear=MAXSIZE

队空：front==rear

顺序队列结构体定义：数据元素，队尾，队头

2.2循环队列

顺序队列是一次性的存在假溢出问题

2.3 计算循环队列的个数

（MAXSIZE-front+rear）%MAXSIZE

2.4链式队列

循环队列在存储数据时有上限，存在队满的情况，适用于数据量较小的情况，所以引出链式队列，没有队满的情况，适用于数据量较大的时候

链式队列的插入和删除等价单向链表的尾插和头删

单链表的尾结点等价于队列的队尾，单链表的