数据结构实验：顺序栈的基本操作及应用

实验内容

用顺序存储结构，实现教材定义的栈的基本操作，提供数制转换功能，将输入的十进制整数转换成二进制、八进制或十六进制。

参考界面

菜单中包括以下功能：

1.初始化栈，2.销毁栈，3.清空栈，4.栈判空，5.求栈长度，6.获取栈顶元素，7.插入一个 元素，8.删除一个元素，9输出所有元素，10进制转换。

要求：自定义的函数中不允许出现提示语和输出语句。

验收/测试用例

通过菜单调用各个操作，测试点：

1. 没有初始化前进行其他操作，程序是否能控制住；
2. 初始化一个栈；
3. 判栈空，屏幕显示栈为空；
4. 3个数入栈， 2、4、6；
5. 栈长度，屏幕输出3；
6. 取栈顶元素，再判栈空，然后再判栈长度。让学生知道取栈顶元素不改变栈中的内容，栈顶指针不发生改变；
7. 出栈，再判栈长度和输出栈中内容；（多次出栈，直到栈为空；再出栈，是否提示栈为空）
8. 销毁栈，再做其他操作，判断程序是否能控制；

数制转换，（允许用户输入想把十进制转换成几进制），然后灵活的转换成对应的进制。

一、设计思想

基于数组实现的顺序栈，包含了栈操作的常见功能，例如初始化栈、销毁栈、清空栈、检查栈是否为空、获取栈的长度、获取栈顶元素、插入和删除元素、打印所有元素，以及一个特殊的进制转换功能。

基本思想是使用一个数组来存储栈中的元素。数组的开始位置作为栈底，一个单独的指针（或数组索引）指向栈顶元素。根据后进先出（LIFO）的原则，新元素总是被添加到栈顶，删除元素也总是从栈顶开始。

具体来说，下面是该代码的主要部分的思想：

1. 初始化栈 InitStack: 分配一段连续的内存空间作为栈空间，初始化栈顶和栈底指针，并指定栈的最大容量。
2. 销毁栈 DestroyStack: 释放栈所占用的内存空间，并将栈顶、栈底指针都设置为空。
3. 清空栈 ClearStack: 将栈顶指针移动到栈底，但不释放内存空间。
4. 检查栈是否为空 Emptystack: 检查栈顶和栈底指针是否相等。如果相等，栈为空；否则，栈非空。
5. 获取栈长度 LengthStack: 使用栈顶指针减去栈底指针来计算栈中的元素数量。
6. 获取栈顶元素 GetTop: 直接返回栈顶指针所指向的元素。栈顶指针指向的是下一个将要插入的位置，所以需要减1来获取真正的栈顶元素。
7. 插入元素 InsertElem: 首先检查栈空间是否足够，如果不够则进行扩容。然后在栈顶位置插入新元素，最后将栈顶指针向上移动一位。
8. 删除元素 DeleteElem: 首先检查栈是否为空。如果栈不为空，则移动栈顶指针以删除栈顶元素。
9. 打印所有元素 PrintElem: 从栈顶到栈底依次打印元素。
10. 进制转换 Conversion:利用栈进行进制转换。将输入的十进制数转换为指定的二进制、八进制或十六进制数。基本思想是将数值除以转换的基数（2，8，16）并将余数存入栈中，然后将商再次进行同样的操作，直到商为0。然后从栈中取出所有元素，就得到了倒序的转换结果。因为栈是后进先出的，所以最后得到的是正序的转换结果。

二、主要源代码

#define _CRT_SECURE_NO_WARNINGS 1 
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10

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

typedef int ElemType;
typedef struct SqStack
{
	ElemType* base;
	ElemType* top;
    int stacksize;
	int ini_flag;
}SqStack;

//功能菜单
void menu()
{
	printf("***指令 菜单***\n");
	printf("1.初始化栈\n");
	printf("2.销毁栈\n");
	printf("3.清空栈\n");
	printf("4.判断栈是否为空\n");
	printf("5.求栈的长度\n");
	printf("6.获取栈顶元素\n");
	printf("7.插入一个元素\n");
	printf("8.删除一个元素\n");
	printf("9.输出所有元素\n");
	printf("10.进制转换\n");
	printf("***************\n");
}

void InitStack(SqStack* S)
{
	S->base = (ElemType*)(malloc((unsigned long long)STACK_INIT_SIZE * sizeof(ElemType)));
	if (!S->base)
		exit(0);
	S->top = S->base;
	S->stacksize = STACK_INIT_SIZE;
	S->ini_flag = 1;
	printf("初始化成功，请输入下一个指令，输入 0 退出程序！\n");

}


//销毁栈
void DestroyStack(SqStack* S)
{
	if (S->ini_flag != 1)
	{
		printf("栈不存在，请先进行初始化！\n");
		return;
	}
	free(S->base);
	S->base = NULL;
	S->top = NULL;
	S->stacksize = 0;
	S->ini_flag = 0;
	printf("销毁成功，请输入下一个指令，输入 0 退出程序！\n");

}

//清空栈
void ClearStack(SqStack* S)
{
	if (S->ini_flag != 1)
	{
		printf("栈不存在，请先进行初始化！\n");
		return;
	}
	S->top = S->base;
	printf("清空成功，请输入下一个指令，输入 0 退出程序！\n");

}

//判断栈是否为空
int Emptystack(SqStack* S)
{
	if (S->ini_flag != 1)
	{
		return 3;
	}
	if (S->base == S->top)
	{
		return 2;
	}
	else
	{
		return 1;
	}
}
//求栈的长度

void LengthStack(SqStack* S)
{
	if (S->ini_flag != 1)
	{
		printf("栈不存在，请先进行初始化！\n");
		return;
	}
	int flag = Emptystack(S);
	if (flag == 2)
	{
		printf("此时栈为空！\n");
	}
	else
		printf("此时栈的长度为：%d\n", S->top - S->base);
}

//获取栈顶元素
void GetTop(SqStack* S)
{
	if (S->ini_flag != 1)
	{
		printf("栈不存在，请先进行初始化！\n");
		return;
	}
	ElemType a;
	a = *(S->top - 1);
	printf("栈顶元素为：%d\n",a);
}
//插入一个元素
ElemType* InsertElem(SqStack* S)
{
	if (S->ini_flag != 1)
	{
		printf("栈不存在，请先进行初始化！\n");
		return;
	}
	//判断此时栈是否还有空间,如果不足，便自动增加
	if (S->top - S->base == S->stacksize)
	{
		S->base = (ElemType*)realloc(S, (STACK_INIT_SIZE + STACKINCREMENT) * sizeof(ElemType));
		S->stacksize= S->stacksize + STACKINCREMENT;
	}
	//扩容完成
	ElemType a;
	printf("请输入要插入的元素：\n");
	scanf("%d", &a);
	*(S->top) = a;
	S->top++;
	printf("插入成功，请输入下一个指令，输入 0 退出程序！\n");
	return S->base;

}
//删除一个元素
ElemType* DeleteElem(SqStack* S)
{
	if (S->ini_flag != 1)
	{
		printf("栈不存在，请先进行初始化！\n");
		return;
	}
	if (S->top == S->base)
	{
		printf("栈为空！\n");
		return 0;
	}
	ElemType p;
	p = *(S->top);
	S->top--;
	printf("删除成功，请输入下一个指令，输入 0 退出程序！\n");
	return p;
}
//输出所有元素
void PrintElem(SqStack* S)
{
	if (S->ini_flag != 1)
	{
		printf("栈不存在，请先进行初始化！\n");
		return;
	}
	if (S->top == S->base)
	{
		printf("栈为空！\n");
		return;
	}
	ElemType* p;
	p = S->top;
	while (p != S->base)
	{
		p--;
		if (*p >= 10 && *p <= 15)
		{
			printf("%c ", 'A' + (*p - 10));
		}
		else
		printf("%d ", *p);
	}
	printf("\n");
}
//进制转换
void Conversion(SqStack* S)
{
	if (S->ini_flag != 1)
	{
		printf("栈不存在，请先进行初始化！\n");
		return;
	}
	//if (S->top - S->base == S->stacksize) // 检查栈是否已满
	//{
	//	S->base = (ElemType*)realloc(S->base, (S->stacksize + STACKINCREMENT) * sizeof(ElemType));
	//	S->stacksize += STACKINCREMENT;
	//}
	/*ClearStack(S);*/
	S->top = S->base;

	int n;
	printf("请输入要转换为几进制数：\n");
	scanf("%d", &n);
	if (n==2)
	{
		int N;
		printf("请输入要转换的十进制数：\n");
		scanf("%d", &N);
		while (N)
		{
			*(S->top) = N % 2;
			S->top++;
			N = N / 2;
		}
		printf("转换后的二进制数为：\n");
		PrintElem(S);
	}
	else if (n == 8)
	{
		int N;
		printf("请输入要转换的十进制数：\n");
		scanf("%d", &N);
		while (N)
		{
			*(S->top) = N % 8;
			S->top++;
			N = N / 8;
		}
		printf("转换后的八进制数为：\n");
		PrintElem(S);
	}
	else if(n==16)
	{
		int N;
		printf("请输入要转换的十进制数：\n");
		scanf("%d", &N);
		while (N)
		{
			*(S->top) = N % 16;
			S->top++;
			N = N / 16;
		}
		printf("转换后的十六进制数为：\n");
		PrintElem(S);
	}
	else
	{
		printf("输入错误,请输入正确的进制数 (2,8,16) ！\n");
	}
}
int main()
{
	SqStack S;
	menu();
	printf("请选择指令：\n");
	int input = 0;
	scanf("%d", &input);
	while (input)
	{
		switch (input)
		{
		case 1:
			InitStack(&S);
			break;
		case 2:
			DestroyStack(&S);
			break;
		case 3:
			ClearStack(&S);
			break;
		case 4:
			Emptystack(&S);
			int flag = Emptystack(&S);
			if (flag == 2)
			{
				printf("此时栈为空！\n");
			}
			else if(flag==1)
				printf("此时栈不为空！\n");
			else
				printf("栈不存在，请先进行初始化！\n");

			break;
		case 5:
			LengthStack(&S);
			break;
		case 6:
			GetTop(&S);
			break;
		case 7:
			InsertElem(&S);
			break;
		case 8:
			DeleteElem(&S);
			break;
		case 9:
			PrintElem(&S);
			break;
		case 10:
			Conversion(&S);
			break;
		default:
			printf("请输入正确的指令！\n");
			menu();
			break;
		}
		scanf("%d", &input);
	}
	return 0;
}

通过菜单调用各个操作，测试点： 没有初始化前进行其他操作，程序是否能控制住； 初始化一个栈； 判栈空，屏幕显示栈为空； 3个数入栈， 2、4、6； 栈长度，屏幕输出3； 取栈顶元素，再判栈空，然后再判栈长度。让学生知道取栈顶元素不改变栈中的内容，栈顶指针不发生改变； 出栈，再判栈长度和输出栈中内容；（多次出栈，直到栈为空；再出栈，是否提示栈为空） 销毁栈，再做其他操作，判断程序是否能控制； 数制转换，（允许用户输入想把十进制转换成几进制），然后灵活的转换成对应的进制。