链栈、顺序栈的基本操作：定义结构的不同，入栈，出栈的区别，取栈顶元素，以及用链栈将十进制的数转换成二进制和用顺序栈存储输入的整数,当ai不等于-1时,ai进栈；当ai等于-1时,输出栈顶整数并出栈

√1、请实现顺序栈的基本操作（定义顺序栈结构，初始化，获取栈顶元素，出栈，入栈等操作）。
√2、请实现链栈的基本操作（定义顺序栈结构，初始化、获取栈顶元素，出栈，入栈等操作）。
√3、在题1的基础上完成：从键盘输入一整数的序列:a1,a2,a3……an,试编写算法实现:用栈结构存储输入的整数,当ai不等于-1时,ai进栈;当ai等于-1时,输出栈顶整数并出栈.算法应对异常情况(入栈满等)给出相应的信息.
√4、题2的基础上完成数制转换:请把一个十进制数N转换为d进制数（数值仅能为2，8，16）,并输出.(实现时,请采用链式存储).

一对一：是指除了第一个元素和最后一个元素，其他元素都只有一个直接前驱和一个直接后继

随机存取：是因为我们可以通过查找地址，通过地址直接对元素进行修改

链表则是顺序：是因为链表在通过指针依次指向下一个节点，直到表尾.

 

 

栈底是表头，栈顶是表尾。（栈底是不动的那一方，我们修改的是栈顶）

无论是顺序表还是顺序栈，只要是顺序存储，都是申请一段连续的空间

前提：在进行栈的操作，一定要预设栈顶指针top

top指针：指向的是入站元素即将如的下一个位置

元素的个数：用top指针减去base指针

链栈

运算是受限的单链表，只能在链表头部进行操作，故没必要附加头结点。栈顶指针就是链表的头指针。

栈的运用：用于数制转换，将十进制转换成八进制、二进制、十六进制等等

//链栈的操作

#include<stdio.h>
#include<stdlib.h>
#include<stack>
#define OK 1
#define ERROR 0
#define INIT_STACK_SIZE 200
#define STACKINCREAM 10
typedef int Status;
typedef int SlemType;
/*
√1、请实现链栈的基本操作（定义顺序栈结构，初始化、获取栈顶元素，出栈，入栈等操作）。
√2、基础上完成数制转换:请把一个十进制数N转换为d进制数（数值仅能为2，8，16）,并输出.(实现时,请采用链式存储).
*/

//定义链栈的结构
typedef struct StackNode
{
	SlemType data;
	struct StackNode *next;
}StackNode,*LinkStack;

//初始化链栈
Status InitStack(LinkStack &s)
{
	s = NULL;
	return OK;
}

//判断栈是否为空
Status StackEmpty(LinkStack s)
{
	if (s == NULL)
		return OK;
	return ERROR;
}

//进栈
Status Push(LinkStack &s, SlemType e)
{
	LinkStack p = (StackNode*)malloc(sizeof(StackNode));
	if (!p)
		return ERROR;
	p->data = e;
	p->next = s;
	s = p;
	return OK;
}

//出栈
Status Pop(LinkStack &s, SlemType &e)
{
	if (s == NULL)
		return ERROR;
	LinkStack p = s;//定义一个指针p保存s的地址
	e = s->data;//e保存s的数据
	s = s->next;//s保存s的next
	free(p);
	return OK;
}

//取栈顶元素
Status GetTop(LinkStack s,SlemType &e)
{
	if (s == NULL)//判断指针是否为空
		return -1;
	e = s->data;
	return e;
}

//清空栈
Status Clearstack(LinkStack &s)
{
	LinkStack p;
	while (s)
	{
		p = s->next;
		free(s);
		s = p;
	}
	return OK;
}

//数值转换
void Conversion2(SlemType n)//转化为二进制
{
	LinkStack s;
	InitStack(s);
	SlemType e;
	while (n)
	{
		Push(s, n % 2);
		n = n / 2;
	}
	while (s)
	{
		Pop(s, e);
		printf("%d", e);
	}
	printf("\n");
}

int main()
{
	/*
	LinkStack s;
	SlemType e;
	InitStack(s);
	for (int i = 1; i <= 5; i++)
		Push(s, i);
	//printf("\n栈顶元素为：%d\n", GetTop(s, e));//放在这里不能运行？
	for (int i = 1; i <= 5; i++)
	{
		Pop(s, e);
		printf("%d ", e);
	}
	printf("\n栈顶元素为：%d\n", GetTop(s, e));
	printf("\n");
	 */
	Conversion2(22);

return OK;

}

#include<stdio.h>
#include<stdlib.h>
#include<stack>
#define OK 1
#define ERROR 0
#define INIT_STACK_SIZE 200
#define STACKINCREAM 10
typedef int Status;
typedef int SlemType;
/*
√1、请实现顺序栈的基本操作（定义顺序栈结构，初始化，获取栈顶元素，出栈，入栈等操作）。
√2、从键盘输入一整数的序列:a1,a2,a3……an,试编写算法实现:用栈结构存储输入的整数,当ai不等于-1时,ai进栈;当ai等于-1时,输出栈顶整数并出栈.算法应对异常情况(入栈满等)给出相应的信息.
*/

//定义顺序栈
typedef struct
{
	SlemType*base;
	SlemType*top;
	int stacksize;
}Sqstack;

//初始化顺序栈
Status Initstack(Sqstack &s)
{
	s.base = (SlemType*)malloc(sizeof(SlemType)*INIT_STACK_SIZE);
	if (!s.base)
		return ERROR;
	s.top = s.base;
	s.stacksize = INIT_STACK_SIZE;
}

//判断是否空栈
Status Stackempty(Sqstack s)
{
	if (s.base == s.top)
		return OK;
	return ERROR;
}

//获取栈中元素的个数
Status Stacklength(Sqstack s)
{
	return s.top - s.base;
}

//清空栈
Status Clearstack(Sqstack &s)
{
	if (s.base)
		s.top = s.base;
	return OK;
}

//销毁栈
Status Destorystack(Sqstack &s)
{
	if (s.base)
		free(s.base);
	s.top = s.base = NULL;
	s.stacksize = 0;
	return OK;
}

//入栈操作
Status Push(Sqstack &s,SlemType e)
{
	if (s.top - s.base >= s.stacksize)//判断栈中元素是否满了，如果满了，就会有如下申请空间的操作
	{
		s.base = (SlemType*)realloc(s.base, sizeof(SlemType)*(INIT_STACK_SIZE + STACKINCREAM));//动态空间分配
		if (!s.base)//判断栈底是否为空
			return ERROR;
		s.top = s.base + s.stacksize;//栈顶指针移动
		s.stacksize = INIT_STACK_SIZE + STACKINCREAM;
	}

	*s.top = e;//将e的值赋值给top位置
	s.top++;//然后将top指针指向下一个空间的位置
	//*s.top++=e;	这两句可以合并成一句
	return OK;
}

//出栈操作
Status Output(Sqstack &s,SlemType &e)
{
	if (s.top == s.base)//判断栈的元素是否为空
		return ERROR;
	s.top--;//top指针往下移
	e = *s.top;//将原先top指向的元素保存在e元素中
	printf("%d\n", e);
	return OK;
}

//取顺序栈栈顶元素 
Status GetTop(Sqstack s, SlemType &e)
{
	if (s.top == s.base)//如果是空栈
		return ERROR;
	e = *(s.top - 1);
	printf("%d ", e);
	//为什么不能用 e=*(s.top--);虽然e最后得到的值都是一样的
	//原因：因为e=*(s.top--)使top指针保存的地址被改变了，而e = *(s.top - 1)中的top指针保存的地址没有改变的，只是top指针向下移动。
}

//在顺序栈的基础上完成：从键盘输入一整数的序列:a1,a2,a3……an,试编写算法实现:用栈结构存储输入的整数,当ai不等于-1时,ai进栈;当ai等于-1时,输出栈顶整数并出栈.算法应对异常情况(入栈满等)给出相应的信息.
Status OutputStruck(Sqstack &s, SlemType &e)
{
	SlemType e1=e;
	Sqstack s1=s;
	Initstack(s1);
	for (e = 3; e > -3; e--)
	{
		if (s1.top - s1.base >= s1.stacksize)//是否栈满的情况
		{
			printf("栈已满，无法输入数据，操作失败！\n");
			return ERROR; 
		}			
		Push(s1, e);
		if (e == -1)//当ai等于-1时,输出栈顶整数并出栈顶整数并出栈
		{
			printf("栈顶元素为：");
			GetTop(s1, e1);
			printf("\n");
			printf("出栈后为：\n");
			for (e1; e1 > -3;e1--)
			Output(s1, e1);
			return ERROR;
		}
	}	
}
int main()
{
	SlemType e;
	Sqstack s;
	OutputStruck(s, e);
	return 0;
}