实验二栈的应用(数制转换)

C语⾔【栈的应⽤数制转换】1 #include <stdio.h>2 #include <malloc.h>3 #include <process.h>4#define OK 15#define STACK_INIT_SIZE 56#define STACKINCREMENT 57 typedef int ElemType;89 typedef struct10 {1112 ElemType *base;13 ElemType *top;14int stacksize;15 }SqStack;16void InitStack(SqStack *S)17 {18 S->base=(ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType)); //分配内存19if(!S->base) //如果为空,则退出20 exit(1);21 S->top=S->base;22 S->stacksize=STACK_INIT_SIZE;23 }24int push(SqStack *S,ElemType e)/*顺序⼊栈*/25 {26if(S->top-S->base>S->stacksize)//栈中的数据长度⼤于给定分配⼤⼩27 {28 S->base=(ElemType *)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(ElemType));//增加内存⼤⼩29if(!S->base)30 exit(1);31 S->top=S->base+S->stacksize;//将增加的长度给更新32 S->stacksize+=STACKINCREMENT;//更新增加后的长度33 }34 *S->top=e;35 S->top++;36return1;3738 }39 ElemType pop(SqStack *S,ElemType *e)/*顺序出栈*/40 {41if(S->top==S->base) //出栈判断栈是否是空42 printf("此时栈为空,不能出栈!\n");43 *e=*--S->top;44return *e;45 }46int StackEmpty(SqStack *S)/*判断顺序栈是否为空*/47 {48if(S->top==S->base)49return1;50else51return0;5253 }54void DestroyStack(SqStack *S)/*顺序栈销毁*/55 {56 free(S->top);57 }5859void Conversion()/*数值转换*/60 {61int n;62int m;63 SqStack s;64 ElemType e;65 InitStack(&s);66 printf("请输⼊带转换的数值:\n");67 scanf("%d",&n);68 printf("请输⼊要转化的数制:\n");69 scanf("%d",&m);70while(n)71 {72 push(&s,n%m);73 n=n/m;74 }75while(!StackEmpty(&s))76 {77 pop(&s,&e);78 printf("%d",e);7981 printf("\n");82 DestroyStack(&s);8384 }85int main(void) /*程序⼊⼝*/86 {87 Conversion();88return OK;89 }1 #include <stdio.h>2 #include <malloc.h>3 #include <process.h>4#define OK 15#define STACK_INIT_SIZE 56#define STACKINCREMENT 57 typedef int ElemType;89 typedef struct10 {1112 ElemType *base;13 ElemType *top;14int stacksize;15 }SqStack;16void InitStack(SqStack *S)17 {18 S->base=(ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType)); //分配内存19if(!S->base) //如果为空,则退出20 exit(1);21 S->top=S->base;22 S->stacksize=STACK_INIT_SIZE;23 }24int push(SqStack *S,ElemType e)/*顺序⼊栈*/25 {26if(S->top-S->base>S->stacksize)//栈中的数据长度⼤于给定分配⼤⼩27 {28 S->base=(ElemType *)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(ElemType));//增加内存⼤⼩29if(!S->base)30 exit(1);31 S->top=S->base+S->stacksize;//将增加的长度给更新32 S->stacksize+=STACKINCREMENT;//更新增加后的长度33 }34 *S->top=e;35 S->top++;36return1;3738 }39 ElemType pop(SqStack *S,ElemType *e)/*顺序出栈*/40 {41if(S->top==S->base) //出栈判断栈是否是空42 printf("此时栈为空,不能出栈!\n");43 *e=*--S->top;44return *e;45 }46int StackEmpty(SqStack *S)/*判断顺序栈是否为空*/47 {48if(S->top==S->base)49return1;50else51return0;5253 }54void DestroyStack(SqStack *S)/*顺序栈销毁*/55 {56 free(S->top);57 }5859void Conversion()/*数值转换*/60 {61int n;62int m;63 SqStack s;64 ElemType e;65 InitStack(&s);66 printf("请输⼊带转换的数值:\n");67 scanf("%d",&n);68 printf("请输⼊要转化的数制:\n");69 scanf("%d",&m);70while(n)71 {72 push(&s,n%m);73 n=n/m;75while(!StackEmpty(&s))76 {77 pop(&s,&e);78 printf("%d",e);7980 }81 printf("\n");82 DestroyStack(&s);8384 }85int main(void) /*程序⼊⼝*/86 {87 Conversion();88return OK;89 }。

数据结构实验⼆：利⽤栈把⼗进制数转换为⼋进制数#include<stdio.h>#include<stdlib.h>#define ok 1#define error 0#define overflow -2typedef struct{int *base,*top;int stacksize;}sqstack;int initstack(sqstack *s){s->base=(int *)malloc(10*sizeof(int)); //预先为s->base所指向的内存空间分配10个int类型的存储空间if(!s->base)return overflow;s->top=s->base;s->stacksize=10;return ok;}int gettop(sqstack *s,int *e){if(s->top==s->base)return error;*e=*(s->top-1);return ok;}int pop(sqstack *s,int *e){if(s->top==s->base)return error;s->top--;*e=*s->top;return ok;}int push(sqstack *s,int e){if(s->top-s->base>=s->stacksize){s->base=(int *)realloc(s->base,(s->stacksize+10)*sizeof(int)); //如果栈满，则再次给s->base所指向的内存空间分配10个int类型的存储空间if(!s->base)return overflow;s->top=s->base+s->stacksize;s->stacksize++;}*s->top=e;s->top++;return ok;}int getlength(sqstack *s) //获取栈的长度作为返回值{int i;i=s->top-s->base;return i;}int convertion(int n) //传⼊⼀个⼗进制数n，返回值为n的⼋进制{int k,t,l,m,sum;sqstack s;initstack(&s);do{k=n%8;push(&s,k);n/=8;}while(n!=0);l=getlength(&s);for(sum=0;l>0;l--){sum*=10; //sum*10表⽰每进⾏⼀次循环⼩数点都向后移动⼀位，即先出栈的元素位权⾼pop(&s,&m);sum+=m;}return sum;}void main(){int i,j;printf("请输⼊⼀个⼗进制数：");scanf("%d",&j);i=convertion(j);printf("⼗进制数%d的⼋进制为：%d\n",j,i);}程序运⾏结果如下：可以发现，⽆论是正数还是负数程序都能进⾏转化。

栈的应⽤-数制转换（C语⾔数据结构）数制转换在计算机中经常⾯对不同数制的转换问题，如将⼀个⼗进制数N转换为d进制B。

数制转换的解决⽅法很多，其中⼀个简单的转换算法是重复下述两步。

直到N等于零为⽌。

x = N mod dN = N div d其中，N为需要转换的⼗进制数，d为转换后的进制，x值为转换后各个数位上的数，div为整除运算，mod为求余运算。

算法的运⾏过程为：第⼀次求出的x值为d进制数的最低位，最后⼀次求出的x值为d进制数的最⾼位，所以上述算法是从低位到⾼位顺序产⽣d进制的各位，然后逆序输出，因为它按“后进先出”的规律进⾏的，所以⽤栈这种结构处理最合适。

根据这个特点，利⽤栈来实现上述数制转换，即将计算过程种⼀次得到的d进制数码按顺序栈进栈。

计算结束后，再返顺序出栈，并按出栈顺序打印输出。

这样即可得到给定的⼗进制数对应的d进制数，由此可以得到数制转换的算法。

实现代码利⽤顺序栈实现数制转换（以⼗进制转换为⼆进制为例）1 #include <stdlib.h>2 #include <stdio.h>3 #define MAXSIZE 102445 /*定义顺序栈*/6 typedef int elemtype;7 typedef struct SequenStack8 {9 elemtype data[MAXSIZE];10 int top;11 }SequenStack;1213 /*判（顺序栈）栈空*/14 SequenStack * Init_SequenStack()15 {16 SequenStack * S;17 S = (SequenStack *)malloc(sizeof(SequenStack));1819 if (S == NULL)20 {21 return S;22 }23 S->top = -1;24 return S;25 }2627 /* 判空栈（顺序栈）*/28 int SequenStack_Empty(SequenStack * S)29 {30 if (S->top == -1)31 {32 return 1;33 }34 else35 {36 return 0;37 }38 }3940 /* ⼊栈（顺序栈） */41 int Push_SequenStack(SequenStack * S, elemtype x)42 {43 if (S->top >= MAXSIZE-1)44 {45 return 0;46 }47 S->top++;48 S->data[S->top] = x;49 return 1;50 }5152 /* 出栈（顺序栈） */53 int Pop_SequenStack(SequenStack * S, elemtype * x)54 {55 if (S->top == -1)56 {57 return 0;58 }59 else60 {61 S->top--;62 *x = S->data[S->top+1];63 return 1;64 }65 }6667 /* 进制转换算法 */68 void SequenStackConversion(int N)69 {70 int x;71 SequenStack * S = Init_SequenStack();72 while (N > 0)73 {74 Push_SequenStack(S, N % 2);75 N = N / 2;76 }77 while (! SequenStack_Empty(S))78 {79 Pop_SequenStack(S, &x);80 printf("%d", x);81 }82 }8384 int main()85 {86 int N;87 printf("Please enter the decimal number you want want to convert:\n");88 scanf("%d", &N);89 printf("The converted binary number is:\n");90 SequenStackConversion(N);91 }实现结果：利⽤链栈栈实现数制转换（以⼗进制转换为⼆进制为例）1 #include <stdio.h>2 #include <stdlib.h>34 /*定义链栈*/5 typedef int elemtype;6 typedef struct LinkedStackNode7 {8 elemtype data;9 struct LinkedStackNode *next;10 }LinkedStackNode, *LinkedStack;11 LinkedStack top;1213 /*链栈的初始化*/14 LinkedStack Init_LinkedStack()15 {16 LinkedStack top = (LinkedStackNode *)malloc(sizeof(LinkedStackNode));1718 if(top != NULL)19 {20 top->next = NULL;21 }22 return top;23 }2425 /*判栈空*/26 int LinkedStack_Empty(LinkedStack top)27 {28 if (top->next == NULL)29 {30 return 1;31 }32 else33 {34 return 0;35 }3637 }3839 /*⼊栈*/40 int Push_LinkedStack(LinkedStack top, elemtype x)41 {42 LinkedStackNode *node;43 node = (LinkedStackNode *)malloc(sizeof(LinkedStackNode));4445 if (node == NULL)46 {47 return 0;48 }49 else50 {51 node->data = x;52 node->next = top->next;53 top->next = node;54 return 1;55 }5657 }5859 /*出栈*/60 int Pop_LinkedStack(LinkedStack top, elemtype * x)61 {62 LinkedStackNode *node;63 if (top->next == NULL)64 {65 return 0;66 }67 else68 {69 node = top->next;70 *x = node->data;71 top->next = node->next;72 free(node);73 return 1;74 }7576 }7778 /*进制转换*/79 void ListStackConversion(int N)80 {81 int x;82 LinkedStack S = Init_LinkedStack();83 while (N > 0)84 {85 Push_LinkedStack(S, N % 2);86 N = N / 2;87 }88 while (! LinkedStack_Empty(S))89 {90 Pop_LinkedStack(S, &x);91 printf("%d", x);92 }9394 }9596 int main()97 {98 int N;99 printf("Please enter the decimal number you want want to convert:\n"); 100 scanf("%d", &N);101 printf("The converted binary number is:\n");102 ListStackConversion(N);103 }实现结果：把顺序栈和链栈两种功能综合在⼀起实现数制转换（以⼗进制转换为⼗六进制为例）1 /* 进制转换 */2 #include <stdlib.h>3 #include <stdio.h>4 #define MAXSIZE 100 /*定义顺序栈的长度*/56 /*定义顺序栈*/7 typedef int elemtype;8 typedef struct SequenStack9 {10 elemtype data[MAXSIZE];11 int top;12 }SequenStack;1314 /*定义链栈*/15 typedef int elemtype;16 typedef struct LinkedStackNode17 {18 elemtype data;19 struct LinkedStackNode *next;20 }LinkedStackNode, *LinkedStack;21 LinkedStack top;2223 /* 顺序栈初始化 */24 SequenStack * Init_SequenStack()25 {26 SequenStack * S;27 S = (SequenStack *)malloc(sizeof(SequenStack));2829 if (S == NULL)30 {31 return S;32 }33 S->top = -1;34 return S;35 }3637 /*链栈的初始化*/38 LinkedStack Init_LinkedStack()39 {40 LinkedStack top = (LinkedStackNode *)malloc(sizeof(LinkedStackNode));4142 if(top != NULL)43 {44 top->next = NULL;45 }46 return top;47 }4849 /*判栈（顺序栈）空*/50 int SequenStack_Empty(SequenStack * S)51 {52 if (S->top == -1)53 {54 return 1;55 }56 else57 {58 return 0;59 }60 }6162 /* 判栈（链栈）空 */63 int LinkedStack_Empty(LinkedStack top)65 if (top->next == NULL)66 {67 return 1;68 }69 else70 {71 return 0;72 }7374 }7576 /* ⼊栈（顺序栈）*/77 int Push_SequenStack(SequenStack * S, elemtype x)78 {79 if (S->top >= MAXSIZE-1)80 {81 return 0;82 }83 S->top++;84 S->data[S->top] = x;85 return 1;86 }8788 /* 出栈（顺序栈） */89 int Pop_SequenStack(SequenStack * S, elemtype * x)90 {91 if (S->top == -1)92 {93 return 0;94 }95 else96 {97 S->top--;98 *x = S->data[S->top+1];99 return 1;100 }101 }102103 /* ⼊栈（链栈） */104 int Push_LinkedStack(LinkedStack top, elemtype x)105 {106 LinkedStackNode *node;107 node = (LinkedStackNode *)malloc(sizeof(LinkedStackNode)); 108109 if (node == NULL)110 {111 return 0;112 }113 else114 {115 node->data = x;116 node->next = top->next;117 top->next = node;118 return 1;119 }120121 }122123 /* 出栈（链栈） */124 int Pop_LinkedStack(LinkedStack top, elemtype * x)125 {126 LinkedStackNode *node;127 if (top->next == NULL)128 {129 return 0;130 }131 else132 {133 node = top->next;134 *x = node->data;135 top->next = node->next;136 free(node);137 return 1;138 }139140 }141142 /* 使⽤顺序⽅式进⾏进制转换的函数 */143 void SequenStackConversion(int N)144 {145 int x;146 SequenStack * S = Init_SequenStack();147 while (N > 0)149 Push_SequenStack(S, N % 16); 150 N = N / 16;151 }152 while (! SequenStack_Empty(S))153 {154 Pop_SequenStack(S, &x);155 switch (x)156 {157 case 10:158 printf("A");159 break;160 case 11:161 printf("B");162 break;163 case 12:164 printf("C");165 break;166 case 13:167 printf("D");168 break;169 case 14:170 printf("E");171 break;172 case 15:173 printf("F");174 break;175 default:176 printf("%d", x);177 break;178 }179 }180 }181182 /* 使⽤链栈⽅式进⾏进制转换的函数 */ 183 void ListStackConversion(int N)184 {185 int x;186 LinkedStack S = Init_LinkedStack(); 187 while (N > 0)188 {189 Push_LinkedStack(S, N % 16);190 N = N / 16;191 }192 while (! LinkedStack_Empty(S))193 {194 Pop_LinkedStack(S, &x);195 switch (x)196 {197 case 10:198 printf("A");199 break;200 case 11:201 printf("B");202 break;203 case 12:204 printf("C");205 break;206 case 13:207 printf("D");208 break;209 case 14:210 printf("E");211 break;212 case 15:213 printf("F");214 break;215 default:216 printf("%d", x);217 break;218 }219220 }221222 }223224 void function()225 {226 printf("-------------------------------------------\n"); 227 }228229 /* 主函数调⽤进制转换函数 */230 int main()231 {232 int N, x;233 printf("Please enter the decimal number you want want to convert:\n");234 scanf("%d", &N);235 function();236 printf("Choose using sequential stack or list stack\n");237 printf("1:Sequential stack 2:list stack:\n");238 function();239 scanf("%d", &x);240 printf("The converted binary number is:\n");241 switch (x)242 {243 case 1:244 SequenStackConversion(N);245 break;246 case 2:247 ListStackConversion(N);248 break;249 default:250 printf("error");251 break;252 }253254 return 0;255 }值得注意的是，当⼗进制转换为⼗六进制的时候，需要考虑输出现实⼤于9的⼗六进制位数，这⾥我们考虑可以使⽤switch开关实现。

实验二栈和队列的应用——数值转换器
实验目的：
本实验的目的是使学生深入了解栈和队列的特征，以便在实际问题背景下灵活运用它们；同时还将巩固这两种结构的构造方法，熟练掌握顺序存储映像和链式映像中各类基本操作的实现。

实验要求：
从键盘输入一个10进制数，编程将其转换成16进制数，并输出。

要求实现下列函数：
(1) 实现链栈的各个基本操作函数；
(2) Transfer( )函数实现进制转换工作；
(3) main( )函数进行调用。

[实现提示]
输入：10进制整数
输出：16进制数（由数字0~9和字符A~F组成）
[测试数据]
由学生自己确定，注意边界数据。

程序运行结果：
程序源码：（后付纸）
实验心得体会：十进制转化为十六进制的方法选用了十进制数除以十六取余，因为最先求出来的余数是个位，然后是百位千位等，所以又用到了栈，使得计数单位最大的最先输出。

判断了如果从11到15就用A-B替换。

实验2 栈实验报告1. 实验目的通过本次实验，使学生了解栈的基本概念和应用，掌握栈的操作算法，培养学生的编程能力和算法思维。

2. 实验环境•编程语言：C/C++•开发工具：Visual Studio/Code/GCC•操作系统：Windows/Linux/macOS3. 实验内容本次实验主要包括以下几个方面的内容：1.实现一个简单的栈数据结构；2.实现栈的常见操作（如入栈、出栈、判空、长度等）；3.利用栈解决括号匹配问题；4.利用栈实现逆波兰表达式求值；5.分析栈在函数调用中的应用。

4. 实验步骤4.1 栈的定义与实现首先，我们需要定义一个栈的数据结构。

在C/C++中，可以使用数组或链表来实现栈。

这里我们使用数组来实现。

#include <stdio.h>#include <stdlib.h>#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int top;} Stack;接下来，我们需要实现栈的常见操作。

入栈（push）void push(Stack* s, int value) {if (s->top >= MAX_SIZE - 1) {printf("栈已满，无法入栈\n");return;s->data[++s->top] = value;出栈（pop）int pop(Stack* s) {if (s->top < 0) {printf("栈已空，无法出栈\n");return -1;return s->data[s->top--];判空（isEmpty）int isEmpty(Stack* s) {return s->top < 0;获取栈长度（length）int length(Stack* s) {return s->top + 1;4.2 括号匹配问题括号匹配问题是栈的一个经典应用。

实训2 利用栈实现任意进制的转换一、实验目的加深对于栈结构的理解，掌握利用栈结构的特点实现进制转换的算法。

二、实验内容利用栈实现进制转换。

三、实验所需设备及软件环境标配笔记本电脑Window2000/xp操作系统、turboc2.0或Turbo C_C++ for Windows 集成实验与学习环境四、实验步骤1.确定堆栈的存储结构：顺序存储或链接存储；2.打开代码编辑环境；3.编辑源程序；顺序存储：#include "stdio.h"#define MAX 100int s[MAX],tp=0;void initstack(){int i;for(i=0;i<MAX;i++)s[i]=0;}void push(x)int x;{if(tp>=MAX){printf("stack full\n");return;}s[tp]=x;tp++;}pop(){int x;tp--;if(tp<0){printf("stack underflow\n");return 0;}x=s[tp];return x;}void conversion(){int e=0,n=0; initstack(); scanf("%d",&n); while(n){push(n%8);n=n/8;}while(!empty()){e=pop();printf("%d",e); }}empty(){if (tp==0)return 1;else return 0;}main(){conversion();}链接存储：#include "stdio.h"struct stack{int d;struct stack *next;};isempty(t)struct stack *t;{return (t==NULL);}push(t,x)struct stack **t;int x;{struct stack *temp;temp=(struct stack *)malloc(sizeof(struct stack));temp->d=x;temp->next=*t;*t=temp;}pop(t)struct stack **t;{ int x;struct stack *t1=*t;x=t1->d;*t=t1->next;free(t1);return(x);}elseprintf("\nempty stack");}void initstack(struct stack **ps) { *ps=NULL;}void conversion(){struct stack *t;int e=0,n=0;scanf("%d",&n);initstack(&t);while(n){push(&t,n%8);n=n/8;}e=pop(&t);printf("%d",e);}}main(){conversion();}4.编译源程序，确认无误后运行，检验是否得到正确运行结果；5.保存程序。

⏹设计要求首先设计一个含有多个菜单项的主控菜单程序，然后再为这些菜单项配上相应的功能。

主控菜单设计要求：程序运行后，显示一个标题“判断表达式括号匹配”，标题下方给出4个菜单项的内容和输入提示：1．输入表达式2．输出表达式3．判断表达式的括号是否匹配并计算表达式的值4．退出请选择1—4：⏹功能要求完成各菜单的功能，能正确判断表达式的括号匹配（括号限圆括弧和方括弧两种），若匹配，利用算符优先法计算表达式的值。

计算表达式值的3个相关函数（后面已给出，可以直接粘贴到程序中使用）:I n(c)---- //判断c是否为运算符Precede(θ1, θ2) ----//判断两运算符θ1, θ2的优先关系Operate(a, θ, b)---- //做四则运算a theta b，返回运算结果⏹实现要求1)可用VC++的引用或c语言用指针实现各功能的调用2)必须用栈实现括号匹配和表达式计算⏹实验提交要求1)画流程图2)实现功能的全部程序3)说明程序设计过程中的难点、解决办法及编程小结或体会。

4)实验及报告必须于2015.4.29提交Status In(SElemType c) //判断c是否为运算符{switch(c){case'+':case'-':case'*':case'/':case'(':case')':case'#':return TRUE;default:return FALSE;}}char Precede(SElemType t1, SElemType t2) //判断两符号的优先关系{SElemType f;switch(t2){case'+':case'-':if(t1=='('||t1=='#')f='<';elsef='>';break;case'*':case'/':if(t1=='*'||t1=='/'||t1==')')f='>';elsef='<';break;case'(':if(t1==')'){ printf("括号不匹配\n");exit(OVERFLOW);}elsef='<';break;case')':switch(t1){case'(':f='=';break;case'#':printf("缺乏左括号\n");exit(OVERFLOW);default:f='>';}break;case'#':switch(t1){case'#':f='=';break;case'(':printf("缺乏右括号\n");exit(OVERFLOW);default:f='>';}}return f;}SElemType Operate(SElemType a,SElemType theta,SElemType b) //做四则运算a theta b，返回运算结果{SElemType c;switch(theta){case'+':return a+b;case'-':return a-b;case'*':return a*b;}return a/b;}教师：曹妍2015.4.10。

实验二栈的基本操作及应用实验学时：2实验类型：（设计型）一、实验目的1. 理解并掌握栈的逻辑结构和链式存储方式；2. 理解栈的相关基本算法；3. 编程实现相关算法并进行验证；4. 学会利用栈解决实际问题；5. 掌握数制转换的实现算法。

二、实验条件Visual C++。

三、实验原理及相关知识1. 顺序栈的存储结构描述2. 基本操作的算法描述实验中涉及栈的构建、入栈、出栈、判断栈是否为空、获取栈顶元素、打印栈中所有元素等操作。

3. 数制转换运算的实现方法假设要将十进制数N转换为d进制数，一个简单的转换算法是重复以下两步，直至N为零：（1）X = N mod d（mod为求余运算）（2）N = N div d （div为整除运算）四、实验步骤1. 实现栈的构建、入栈、出栈、判断栈是否为空、获取栈顶元素、打印栈中所有元素等基本操作的函数。

2. 调用基本操作函数实现以下功能：(1) 构建一个空栈；(2) 将1,2,3,4入栈；(3) 输出栈顶元素；(4) 输出栈中所有元素；(5) 按照1,2,3,4的顺序依次入栈；(6) 输出三种不同的出栈序列；(7) 将十进制数20转化为8进制数。

五、思考题及其它1. 在将一个非负十进制数转换成十六进制数时，10-15是转换成字母A-F输出的，如何解决这个问题？【参考程序】#include "stdio.h"#include "malloc.h"#define OK 1#define ERROR 0#define INIT_SIZE 100#define INCREMENT 10typedef int SElemType;typedef struct {SElemType *base ;SElemType *top ;int stacksize ; // 栈的可用最大容量}SqStack;int InitStack(SqStack *S){// 创建一个空栈S(*S).base=(SElemType *)malloc(INIT_SIZE*sizeof(SElemType));if(!(*S).base)return ERROR;;(*S).stacksize=INIT_SIZE;return OK;}int StackEmpty(SqStack *S){ //判断栈是否为空，为空则返回1，否则返回0if( )return 1;elsereturn 0;}int GetTop(SqStack S, SElemType *e){ // 取出栈顶元素if(S.top>S.base){*e =*(S.top-1);printf("栈顶元素是:%d",*e);printf("\n");return OK;}elsereturn ERROR;}int Push( SqStack *S, SElemType e ){ //将数据元素e入栈if((*S).top-(*S).base>=(*S).stacksize) {(*S).base=(SelemType *)realloc((*S).base,((*S).stacksize+INCREMENT)*sizeof(SElemType)); if(!(*S).base)return 0;(*S).top = (*S).base+(*S).stacksize;(*S).stacksize+=INCREMENT;};return OK;}int Pop(SqStack *S, SElemType *e){ //如栈不为空，将栈顶元素出栈if((*S).top ==(*S).base)return ERROR;(*S).top--;;return OK;}void Print_SqStackTraverse( SqStack S ) //输出栈中元素{ //实现此函数}void conversion(int N ,int r) //把十进制数N转换为r进制{ //实现此函数}main(){SqStack S;InitStack(&S);//将1,2,3,4入栈//输出栈顶元素//输出栈中所有元素//按照1,2,3,4的顺序依次入栈，输出三种不同的出栈序列//将十进制数20转化为8进制数}。

Java数据结构——栈的应⽤（以数制转换为例⼦）看⼀万遍，不如⾃⼰动⼿实践，请不要直接copy代码，先⾃⼰去理解例⼦实现的原理，然后试着⾃⼰动⼿去实践。

⽤Java去实现栈操作，会⽤到stack这个类，这类中有⼏个⽅法需要知道他们的⽤法
boolean empty()
测试堆栈是否为空。

Object peek( )
查看堆栈顶部的对象，但不从堆栈中移除它。

Object pop( )
移除堆栈顶部的对象，并作为此函数的值返回该对象。

Object push(Object element)
把项压⼊堆栈顶部。

import java.util.Scanner;
import java.util.Stack;
public class Main
{
public static void main(String[] args)
{
final int type = 8;
int num = 0;
Scanner scanner = new Scanner(System.in);
num = scanner.nextInt();
Stack stack = new Stack();
while(num != 0)
{
stack.push(num%type);
num = num/8;
}
while(!stack.empty())
{
System.out.print(stack.peek());
stack.pop();
}
}
}。