您的位置：360文档中心› 数据结构实验报告栈进制转换

数据结构实验报告栈进制转换

合集下载

数据顺序栈实验报告

数据顺序栈实验报告

一、实验目的1. 理解顺序栈的定义、性质和基本操作。

2. 掌握顺序栈的顺序存储结构及其实现方法。

3. 熟练运用顺序栈解决实际问题，如进制转换、括号匹配等。

4. 提高编程能力和问题解决能力。

二、实验环境1. 操作系统：Windows 102. 编程语言：C语言3. 开发环境：Visual Studio三、实验内容1. 顺序栈的定义和性质2. 顺序栈的顺序存储结构及其实现3. 顺序栈的基本操作：入栈、出栈、判空、判满、取栈顶元素4. 顺序栈的应用：进制转换、括号匹配四、实验步骤1. 定义顺序栈的数据结构```c#define MAXSIZE 100 // 顺序栈的最大容量typedef struct {char data[MAXSIZE]; // 存储栈中元素的数据数组int top; // 栈顶指针} SeqStack;```2. 初始化顺序栈```cvoid InitStack(SeqStack S) {S->top = -1; // 初始化栈顶指针为-1，表示栈为空}```3. 判断栈是否为空```cint StackEmpty(SeqStack S) {return S.top == -1; // 栈顶指针为-1时，表示栈为空}```4. 判断栈是否满```cint StackFull(SeqStack S) {return S.top == MAXSIZE - 1; // 栈顶指针等于最大容量减1时，表示栈满}```5. 入栈操作```cvoid Push(SeqStack S, char x) {if (StackFull(S)) {printf("栈满\n");return;}S->data[++S->top] = x; // 将元素x压入栈顶}```6. 出栈操作```cchar Pop(SeqStack S) {if (StackEmpty(S)) {printf("栈空\n");return 0;}return S->data[S->top--]; // 返回栈顶元素，并将栈顶指针减1 }```7. 取栈顶元素```cchar GetTop(SeqStack S) {if (StackEmpty(S)) {printf("栈空\n");return 0;}return S.data[S.top]; // 返回栈顶元素}```8. 顺序栈的应用（1）进制转换```cvoid DecimalToBinary(SeqStack S, int num) {SeqStack binaryStack;InitStack(&binaryStack);while (num > 0) {Push(&binaryStack, (num % 2) + '0'); // 将余数压入栈中num /= 2;}printf("十进制数 %d 转换为二进制数为：", num);while (!StackEmpty(binaryStack)) {printf("%c", Pop(&binaryStack)); // 依次弹出栈中元素，得到二进制数}printf("\n");}```（2）括号匹配```cint BracketMatch(char str) {SeqStack stack;InitStack(&stack);for (int i = 0; i < strlen(str); i++) {if (str[i] == '(' || str[i] == '[' || str[i] == '{') {Push(&stack, str[i]); // 将左括号压入栈中} else if (str[i] == ')' || str[i] == ']' || str[i] == '}') {if (StackEmpty(stack)) {return 0; // 右括号多于左括号，不匹配}char top = Pop(&stack); // 弹出栈顶元素if ((str[i] == ')' && top != '(') || (str[i] == ']' &&top != '[') || (str[i] == '}' && top != '{')) {return 0; // 左右括号不匹配}}}return StackEmpty(stack); // 栈为空，表示括号匹配}```五、实验结果与分析1. 实验结果通过实验，成功实现了顺序栈的定义、性质、顺序存储结构、基本操作和应用。

《C数据结构》数制转换实验报告

《C数据结构》数制转换实验报告

数制转换实验目的：使用堆栈的存储结构实现数制转换，如10进制->2进制等实验思路：1、写出堆栈的相关操作函数，如：创建【int InitStack( SqStack *S )】、压入【int Push(SqStack *S,int e)】、弹出【int Pop(SqStack *S,int *e)】、销毁【void DestroyStack(SqStack *S)】、判断是否为空【int StackEmpty(SqStack *S)】等。

2、堆栈的各操作函数完成后编写功能函数——数制转换【voidchangeNumber(int *num,int to)】。

3、数制转换函数之后编写主函数，使用上述函数实现数制转换的功能核心代码：1、数制转换函数：void changeNumber(int *num,int to){int result[100],yu,e,m,i=0,j=0; //result[]是转换后的结果，yu是取余的结果SqStack S;for(m=0;m<100;m++){result[m]='#';}InitStack(&S);while(*num!=0){yu=*num%to;Push(&S,yu);*num=*num/to;}while(!StackEmpty(&S)){Pop(&S,&e);result[i]=e;i++;}while(1){printf("%d",result[j]);j++;if(result[j]=='#'){printf("\n");break;}}DestroyStack(&S);}2、主函数：int main(){int *p,num,to;int ok;while(1){printf("您想转换的数字是：");scanf("%d",&num);printf("转换成多少进制：");scanf("%d",&to);p=&num;changeNumber(p,to);while(1){printf("继续请按1，退出请按0...");scanf("%d",&ok);if(ok!=0 && ok!=1){printf("抱歉，您的输入有误,");}else if(ok==0 || ok==1){break;}}if(ok==0){break;}}system("pause");return 1;}功能演示：1、运行执行文件，进入dos窗口后可见提示：“您想转换的数字是：”2、输入：“1000”，回车后可见提示：“转换成多少进制：”3、输入：“6”，回车，得到结果：“4344”，又见提示：“继续请按1，退出请按0...”4、输入0退出。

数据结构-进制转换实验报告

数据结构-进制转换实验报告

计算机科学与技术系实验报告专业名称计算机科学与技术课程名称《数据结构》项目名称栈实现进制的转换班级学号姓名同组人员无实验日期一、实验目的与要求：（简述本次实验要求达到的目的，涉及到的相关知识点，实验的具体要求。

）（一）实验目的：应用栈来实现对数据的操作。

掌握，进栈，出栈（二）实验要求：用栈实现对数据进制的转换（三）实验环境：VC++6.0.二、实验内容#include <stdio.h>#include <malloc.h>#define maxlen 100typedef int dataType;typedef struct{dataType data[maxlen];int top;}seqstack;/*置空栈*/seqstack *Initstack(seqstack *S){S->top = -1;return S;}/*初始化栈*/seqstack *setstack(){seqstack *S;S = (seqstack *) malloc (sizeof(seqstack));S->top = -1;return S;}/*判断栈空*/int stackEmpty(seqstack *S){if(S->top<0)return 1;elsereturn 0;}/*判断栈满*/int stackFull(seqstack *S){if(S->top < (maxlen -1) && S->top >= -1) return 0;elsereturn 1;}/*入栈*/void push(seqstack *S, dataType x){if(stackFull(S))printf("此栈已经满\n");else{S->top ++;S->data[S->top] = x;}}/*出栈*/dataType pop(seqstack *S){dataType x;if(stackEmpty(S))printf("此栈为空\n");else{x = S->data[S->top];S->top--;}return x;}void main(){seqstack *S;dataType e;int m,n;S = setstack();printf("请输入一个十进制的数：");scanf("%d", &e);printf("请输入你想转出成的进制：");scanf("%d", &m);while(e){n = e%m;push(S,n);e = e/m;}printf("转换成%d进制为：", m);while(!stackEmpty(S)){e = pop(S);printf("%d",e);}printf("\n");}三、实验分析与小结（实验过程中的问题分析、产生的原因以及解决方法；实验结果分析；有待优化思路）（一）实验结果截图（二）总结通过栈，先进后出的特点，我们可以对数据实现进制的转换。

数据结构实验报告 栈进制转换

数据结构实验报告 栈进制转换

数据结构实验报告栈进制转换数据结构实验报告栈进制转换一、实验目的栈是一种常见的数据结构，本实验的目的在于通过实现栈的基本操作，设计并实现一个进制转换的程序，并通过实验验证程序的正确性和效率。

二、实验原理1.栈的定义和基本操作栈是一种后进先出（Last In First Out，简称LIFO）的数据结构。

它可以通过一个指针来标识当前栈顶元素，栈顶指针top的起始值为-1，空栈时top=-1.2.栈的进制转换将一个十进制数转换为其他进制（如二进制、八进制、十六进制）的过程中，可以通过栈来实现。

具体步骤如下：- 初始化一个空栈；- 将十进制数依次除以目标进制的基数，将余数依次入栈，直到商为0；- 依次出栈，将出栈的余数组合起来，得到转换后的目标进制数。

三、实验内容1.实现栈的基本操作（1）定义栈结构，包括元素数组和栈顶指针；（2）实现入栈操作push()，将元素插入到栈顶；（3）实现出栈操作pop()，从栈顶删除一个元素并返回其值；（4）实现获取栈顶元素的操作getTop()，返回栈顶元素的值；（5）实现判断栈是否为空的操作isEmpty()，返回布尔值；（6）实现判断栈是否已满的操作isFull()，返回布尔值。

2.设计并实现进制转换的程序（1）初始化一个空栈用于存放转换后的数字；（2）输入十进制数num和目标进制target；（3）通过栈的操作将num转换为target进制数；（4）输出转换后的结果。

四、实验步骤1.实现栈的基本操作（1）定义栈的结构和相关操作；（2）编写相应的测试代码，验证栈的基本操作是否正确。

2.设计并实现进制转换的程序（1）根据原理部分的步骤，设计转换程序的具体逻辑；（2）编写相应的测试代码，验证转换程序的正确性和效率。

五、实验结果与分析1.给定一个十进制数num=12345，目标进制为二进制（target=2），经过进制转换后得到的结果为.111.2.给定一个十进制数num=456，目标进制为八进制（target=8），经过进制转换后得到的结果为.710.本实验的结果表明，转换程序能够正确地将十进制数转换为目标进制数，并且具有较高的效率。

SDUT2131数据结构实验之栈与队列一：进制转换

SDUT2131数据结构实验之栈与队列一：进制转换

SDUT2131数据结构实验之栈与队列⼀：进制转换数据结构实验之栈与队列⼀：进制转换Time Limit: 1000 ms Memory Limit: 65536 KiBProblem Description输⼊⼀个⼗进制⾮负整数，将其转换成对应的 R (2 <= R <= 9) 进制数，并输出。

Input第⼀⾏输⼊需要转换的⼗进制⾮负整数；第⼆⾏输⼊ R。

Output输出转换所得的 R 进制数。

Sample Input12798Sample Output2377提⽰：本题属于栈操作，可以借助栈来完成，⾸先要明⽩其他进制转化为⼗进制的原理，从⽽反向推出由⼗进制转化为其他进制的⽅法，具体操作代码中会注释。

代码实现如下（g++）：#include <bits/stdc++.h>using namespace std;int main(){stack<int>t;//C++中建栈⽅便，可以直接⽤stack代替int n,r,b;std::ios::sync_with_stdio(false);//防⽌使⽤cin超时cin>>n;cin>>r;if(n==0)cout<<"0";//0的话进制转化均为0，要注意while(n>0){b=n/r;t.push(n%r);//将n对r取模⼊栈n=b;}while(!t.empty()){cout<<t.top();//将栈顶数据出栈t.pop();}return0;}/***************************************************Result: AcceptedTake time: 0msTake Memory: 208KB****************************************************/。

《数据结构》实验报告

《数据结构》实验报告

《数据结构》实验报告实验一一、实验目的及要求理解线性表的顺序存储结构；熟练掌握顺序表结构及其有关算法的设计；理解线性表的链式存储结构；熟练掌握动态链表结构及其有关算法的设计；根据具体问题的需要，设计出合理的表示数据的链表结构，并设计相关算法；深入了解栈和队列的特性，以便在实际问题背景下灵活运用他们；同时巩固对这两种结构的构造方法的理解。

二、实验环境硬件：计算机软件：Microsoft Visual C++三、实验内容1.以顺序表作存储结构，实现线性表的插入、删除；2.以单链表作存储结构，实现有序表的合并；3.利用栈（以顺序栈作存储结构）实现进制转换，并用队列（以链队列作存储结构）计算并打印杨辉三角。

四、源程序清单五、实验结果六、总结实验二一、实验目的及要求掌握二叉树的动态存储结构--二叉链表，掌握二叉树的三种遍历方法，会运用三种遍历的方法求解有关问题。

二、实验环境硬件：计算机软件：Microsoft Visual C++三、实验内容1.以二叉链表作存储结构，建立一棵二叉树；2.输出其先序、中序、后序遍历序列；3.求出它的深度；4.统计其叶子结点数四、源程序清单五、实验结果六、总结实验三一、实验目的及要求掌握图的存储结构及其建立算法，熟练掌握图的两种遍历算法及其应用。

二、实验环境硬件：计算机软件：Microsoft Visual C++三、实验内容1.以邻接矩阵法作存储结构，建立一个无向图；2.输出该图的深度优先搜索序列；3.输出该图的广度优先搜索序列；4. 设计算法求出该图的连通分量个数及边的数目。

四、源程序清单五、实验结果六、总结实验四一、实验目的及要求掌握顺序表的查找方法，尤其是折半查找方法。

掌握二叉排序树的查找算法。

二、实验环境硬件：计算机软件：Microsoft Visual C++三、实验内容1.建立一个顺序表，用顺序查找的方法对其实施查找；2.建立一个有序表，用折半查找的方法对其实施查找；3.建立一个二叉排序树，根据给定值对其实施查找；4.对同一组数据，试用三种方法查找某一相同数据，并尝试进行性能分析。

数据结构栈和队列实验报告

数据结构栈和队列实验报告
while(top-&gt;next!=NULL){
num=Pop(top);
printf(&quot;%d&quot;,num);
}
printf(&quot;\n&quot;);
}
void Push(LinkStack *top,DataType x) /*压栈操作*/
i--;
}
q-&gt;rear-&gt;next=p;
q-&gt;rear=p;
}
void PutQ(LinkQueue *q,int i,int t)
{
int j=t-i-1;
p=q-&gt;front-&gt;next;
while(j){printf(&quot; &quot;);j--;}
scanf(&quot;%d&quot;,&amp;t);
top=(LinkStack*)malloc(sizeof(LinkStack));
IniStack(top);
while(num!=0){
Push(top,num%t);
num=num/t;
}
printf(&quot;转化后的数为:&quot;);
数据结构栈和队列实验报告
（以下写实验内容、分析与程序清单、调试报告等）
一、 实验目的
1.掌握栈这种数据结构特性及其主要存储结构，并能在现实生活中灵活运用。
2.掌握队列这种数据结构特性及其主要存储结构并能在现实生活中灵活运用。
}
}
return 0;

东软数据结构实验报告——通过栈和队列来实现进制转换

东软数据结构实验报告——通过栈和队列来实现进制转换

实验报告（一）实验过程一、项目简介进制转换通过编写函数实现十进制浮点数到R进制的转换，在十进制浮点数的整数部分利用栈结构实现，小数部分用队列结构实现。

二、项目实施：1.读取数据并获得小数点位置2.将字符串转为整数形式.3.对整数部分进行入栈4.获得小数部分并入队5.整数和小数的联合输出6.源代码：#include <stdio.h>#include <string.h>#include <math.h>#define size 10 //小数部分大小#define maxsize 20 //整数部分大小//*********************************//*********************************//小数部分——队列typedef struct{char data[10]; //读取转制后的小数部分int front,rear; //队首尾指针}Queue; //循环队列//*********************************//初始化队列void init_Queue(Queue* q){q->front=q->rear=0;}//*********************************//入队int push_Queue(Queue *q,int x){if((q->rear+1)%size==q->front) //判断队满{printf("队列满！不允许入队\n");return 0;}else{q->rear=(q->rear+1) % size;q->data[q->rear]=x;return 1;}}//********************************* //出队int pop_Queue(Queue *q,int *x){if(q->rear==q->front){printf("队空！");return 0;}else{q->front=(q->front+1)%size;*x=q->data[q->front]; //读取队头元素return 1;}}//*********************************//*********************************//整数部分——栈typedef struct{char dataint[100];int top;}Stack;//*********************************//-制空栈void init_Stack(Stack *s){s->top=0;}//*********************************//进栈int push_Stack(Stack *s,int x){if(s->top==maxsize){printf("栈已满！");return 0;}else{s->dataint[s->top]=x; //数据进栈s->top++;return 1;}}//*********************************//出栈int pop_Stack(Stack *s,int *x){if(s->top==0){printf("栈空，无数据可取!");return 0;}else{s->top--;*x=s->dataint[s->top]; //取处数据return 1;}}//********************************* 主程序int main(){//*********************************//读入数据char a[20];int aim;printf("请输入一个十进制浮点数： "); //以字符串形式输入一个浮点数gets(a);printf("请输入目标进制： ");scanf("%d",&aim);if(aim==1) {printf("ERROR! PLEASE INPUT A NUMBER AND IT IS BIGGER THAN 1");return 0;}//*********************************//读取小数点位置int i;int pos;//小数点位置for(i=0;i<strlen(a);++i){if(a[i]=='.'){pos=i;break;}}//*********************************//定义栈对整数部分转化后并入栈Stack ss;init_Stack(&ss);//初始化栈//*********************************//将整数部分转换为 int 型int begin=1;int bnum;if(a[0]=='-') {int bnum = a[1]-'0'; //判断是否为负数begin=2;}else bnum=a[0]-'0';for(i=begin;i<pos;i++){bnum=bnum*10+a[i]-'0';}// printf("整数部分：%d\n",bnum);//依次求得所转进制的每一位并入栈while(bnum){// if(bnum/aim!=0)push_Stack(&ss,bnum%aim);bnum=bnum/aim;}//*********************************//出栈读取整数部分结果int flag,z;flag=pop_Stack(&ss,&z);if(flag==1){printf("目的进制数为： ");for(i=ss.top;i>=0;i--) //先从顶端出栈printf("%d ",ss.dataint[i]);}else printf("无数据！");// printf("\n");//定义队列并将小数部分转化后入队Queue q,*cq=&q;init_Queue(cq);//*********************************//将小数点后面的部分转为浮点数int c=1;int anum=a[pos+1]-'0';for(i=pos+2;i<strlen(a);i++){anum=anum*10+(a[i]-'0');c++;}double small=((double)anum)/pow(10,c); // printf("小数部分：%lf\n",small);//*********************************// 依次求得小数部分的每一位并入队int zz;int innum;for(i=0;i<6;i++){innum=(((int)(small*aim)))%10; //取出小数点前的部分small=small*aim-innum; //得到减去小数点前段的部分继续与aim 相乘push_Queue(cq,innum);}//*********************************//出队列printf(".") ;if(pop_Queue(cq,&zz)){for(i=(cq->front)%size;i!=(cq->rear+1)%size;i=(i+1)%size)printf("%d ",cq->data[i]);}//*********************************return 0;}实验总结通过对数据的单个读取并入栈，后续的出栈顺序为从上到下，先进后出，读取数据后为相反的顺序，而队列的顺序出队为先进先出，对小数的存储可直接进行读取。

数据结构实验报告栈

数据结构实验报告栈

数据结构实验报告：栈摘要：本实验报告旨在介绍栈这一重要的数据结构，以及在实际应用中的使用。

栈是一种先进后出（LIFO）的数据结构，在计算机科学中有着广泛的应用。

本报告将详细介绍栈的定义、基本操作以及应用实例，并根据实验结果进行分析和总结。

1. 引言栈是一种基于线性表的数据结构，具有后进先出（LIFO）的特性。

它可以通过两个基本操作来实现：push（入栈）将元素添加到栈顶，pop（出栈）将栈顶元素移除。

栈在计算机科学中被广泛应用，如函数调用、表达式求值、括号匹配等。

2. 栈的实现栈可以通过数组或链表来实现。

数组实现的栈称为顺序栈，链表实现的栈称为链式栈。

无论是哪种实现方式，都需要实现以下基本操作：- push(element): 将元素添加到栈顶。

- pop(): 移除栈顶元素并返回。

- top(): 返回栈顶元素的值。

- isEmpty(): 判断栈是否为空。

- isFull(): 判断栈是否已满（仅顺序栈需要实现）。

3. 栈的应用3.1 函数调用栈在函数调用中起着关键作用。

每当一个函数被调用时，当前函数的局部变量、返回地址等信息都会被压入栈中。

当函数执行完毕时，这些信息会从栈中弹出，继续执行上一级函数。

3.2 表达式求值栈常用于表达式求值，特别是中缀表达式的转换和计算。

通过将中缀表达式转换为后缀表达式，可以方便地进行计算。

栈可以临时存储运算符，并根据运算符的优先级进行弹出和计算。

3.3 括号匹配栈的一个重要应用是括号匹配。

通过遍历字符串，将左括号压入栈中。

每当遇到右括号时，如果栈顶元素是匹配的左括号，则弹出栈顶元素；否则，表示括号不匹配。

4. 实验结果与分析根据我们对栈的实现和应用进行的实验，以下是我们得到的结论：- 通过数组实现的顺序栈在空间上存在一定的限制，可能会出现栈溢出的情况。

- 通过链表实现的链式栈没有空间限制，可以动态地添加和删除元素。

- 栈在函数调用和表达式求值中展现出了高效的性能，并能够简化程序的设计。

堆栈进制转换实验报告

堆栈进制转换实验报告

一、实验目的1. 理解堆栈的基本原理和操作。

2. 掌握利用堆栈实现进制转换的方法。

3. 提高编程能力，培养问题解决能力。

二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验原理进制转换是将一个数从一种进制表示转换为另一种进制表示的过程。

例如，将十进制数转换为二进制数、十六进制数等。

堆栈是一种先进后出（FILO）的数据结构，可以用来实现进制转换。

进制转换的原理如下：1. 将十进制数转换为任意进制数，需要不断除以目标进制，直到商为0。

2. 将每次除法得到的余数存储在堆栈中，最后从堆栈中取出余数，倒序输出即为转换后的结果。

四、实验步骤1. 定义一个堆栈结构体，包含栈顶指针、栈底指针、栈大小和栈元素。

2. 实现堆栈的基本操作，如初始化、入栈、出栈和判断是否为空。

3. 编写进制转换函数，将十进制数转换为任意进制数。

4. 编写主函数，实现用户输入、进制转换和输出转换结果。

五、实验代码```cpp#include <iostream>#include <stack>using namespace std;// 堆栈结构体定义template <typename T>struct Stack {T base;T top;int size;int capacity;};// 初始化堆栈template <typename T>void initStack(Stack<T>& s, int capacity) { s.base = new T[capacity];s.top = s.base;s.size = 0;s.capacity = capacity;}// 入栈template <typename T>bool push(Stack<T>& s, T element) {if (s.size >= s.capacity) {return false;}s.top = element;s.top++;s.size++;return true;}// 出栈template <typename T>bool pop(Stack<T>& s, T& element) { if (s.size <= 0) {return false;}s.top--;element = s.top;s.size--;return true;}// 判断堆栈是否为空template <typename T>bool isEmpty(Stack<T>& s) {return s.size == 0;}// 十进制数转换为任意进制数template <typename T>void decimalToBase(T decimal, int base) { stack<T> resultStack;while (decimal > 0) {resultStack.push(decimal % base); decimal /= base;}while (!resultStack.empty()) {T element;pop(resultStack, element);cout << element;}cout << endl;}int main() {int decimal;int base;cout << "请输入十进制数：";cin >> decimal;cout << "请输入目标进制（2-16）："; cin >> base;if (base < 2 || base > 16) {cout << "目标进制无效！" << endl;return 0;}cout << "转换后的" << base << "进制数为：";decimalToBase(decimal, base);return 0;}```六、实验结果与分析1. 当输入十进制数65和进制8时，程序输出101，符合预期。

数据结构实验报告_栈(3篇)

数据结构实验报告_栈(3篇)

第1篇一、实验目的本次实验旨在通过实际操作，加深对栈这一数据结构的理解，掌握栈的基本操作，包括初始化、入栈、出栈、取栈顶元素、判栈空等。

同时，通过实验练习，提高编程能力和问题解决能力。

二、实验内容1. 栈的定义及特点2. 栈的顺序存储结构3. 栈的链式存储结构4. 栈的基本操作5. 栈的应用实例三、实验过程1. 栈的定义及特点栈是一种后进先出（LIFO）的数据结构，它只允许在一端进行插入和删除操作。

栈的顶元素总是最后被插入的元素，也是最先被删除的元素。

2. 栈的顺序存储结构顺序存储结构是使用数组来实现栈。

定义一个数组作为栈的存储空间，同时定义一个指针top来指示栈顶元素的位置。

3. 栈的链式存储结构链式存储结构是使用链表来实现栈。

定义一个节点结构体，其中包含数据和指向下一个节点的指针。

头节点作为栈顶元素。

4. 栈的基本操作（1）初始化：创建一个空栈，top指针指向栈底。

（2）入栈：将新元素插入到栈顶。

如果栈满，则进行扩容。

（3）出栈：删除栈顶元素，并将其返回。

如果栈空，则返回错误信息。

（4）取栈顶元素：返回栈顶元素的值，但不删除栈顶元素。

（5）判栈空：判断栈是否为空，如果为空，则返回true；否则，返回false。

5. 栈的应用实例（1）括号匹配检验：利用栈判断一个字符串中的括号是否匹配。

（2）算术表达式求值：利用栈实现算术表达式求值，包括四则运算和括号。

四、实验结果与分析1. 初始化栈初始化栈后，栈为空，top指针指向栈底。

2. 入栈操作将元素1、2、3依次入栈，栈的状态如下：```top -> 3 -> 2 -> 1```3. 出栈操作依次出栈元素，栈的状态如下：```top -> 2 -> 1```4. 取栈顶元素取栈顶元素2，栈的状态不变。

5. 判栈空当栈中只有一个元素时，判断栈为空，返回false。

6. 括号匹配检验对于字符串"((()))"，括号匹配检验结果为true；对于字符串"(()))"，括号匹配检验结果为false。

数据结构实验报告-栈进制转换

数据结构实验报告-栈进制转换

数据结构实验报告-栈进制转换数据结构实验报告栈进制转换一、实验目的本实验旨在通过使用栈这种数据结构，实现不同进制之间的转换，加深对栈的基本概念、操作和应用的理解，提高编程能力和问题解决能力。

二、实验环境操作系统：Windows 10编程语言：C+＋开发工具：Visual Studio 2019三、实验原理进制转换是将一个数从一种进制表示形式转换为另一种进制表示形式的过程。

常见的进制有二进制、八进制、十进制和十六进制。

栈是一种特殊的线性表，它遵循“后进先出”（Last In First Out，LIFO）的原则。

在进制转换中，可以利用栈来存储转换过程中的余数，从而实现进制的转换。

以十进制转换为二进制为例，将十进制数除以 2 取余数，然后将商继续除以 2 取余数，直到商为 0。

将依次得到的余数从栈中取出，即可得到对应的二进制数。

四、实验内容与步骤（一）数据结构定义｀｀｀cppclass Stack ｛private:int stackArray;int top;int capacity;public:Stack(int size) ｛capacity ＝ size;stackArray ＝ new intcapacity;top ＝－1;｝～Stack(）｛delete stackArray;｝void push(int element) ｛if （isFull(））｛std:：cout ＜＜＂Stack Overflow" ＜＜ std:：endl; return;｝stackArray+＋top ＝ element;｝int pop(）｛if （isEmpty(））｛std:：cout ＜＜＂Stack Underflow" ＜＜ std:：endl; return －1;｝return stackArraytop;｝int peek(）｛if （isEmpty(））｛std:：cout ＜＜＂Stack is empty" ＜＜ std:：endl; return －1;｝return stackArraytop;｝bool isEmpty(）｛return top ＝＝－1;｝bool isFull(）｛return top ＝＝ capacity 1;｝｝；｀｀｀（二）十进制转二进制函数｀｀｀cppvoid decimalToBinary(int decimalNumber) ｛Stack stack(32)；while （decimalNumber ＞ 0) ｛int remainder ＝ decimalNumber ％ 2;stackpush(remainder)；decimalNumber ／＝ 2;｝std:：cout ＜＜＂十进制＂＜＜ decimalNumber ＜＜＂转换为二进制为: ＂；while （！stackisEmpty(））｛std:：cout ＜＜ stackpop(）；｝std:：cout ＜＜ std:：endl;｝｀｀｀（三）十进制转八进制函数｀｀｀cppvoid decimalToOctal(int decimalNumber) ｛Stack stack(16)；while （decimalNumber ＞ 0) ｛int remainder ＝ decimalNumber ％ 8;stackpush(remainder)；decimalNumber ／＝ 8;｝std:：cout ＜＜＂十进制＂＜＜ decimalNumber ＜＜＂转换为八进制为: ＂；while （！stackisEmpty(））｛std:：cout ＜＜ stackpop(）；｝std:：cout ＜＜ std:：endl;｝｀｀｀（四）十进制转十六进制函数｀｀｀cppvoid decimalToHexadecimal(int decimalNumber) ｛Stack stack(16)；while （decimalNumber ＞ 0) ｛int remainder ＝ decimalNumber ％ 16;if （remainder ＜ 10) ｛stackpush(remainder ＋＇0'）；｝ else ｛stackpush(remainder 10 ＋＇A'）；｝decimalNumber ／＝ 16;｝std:：cout ＜＜＂十进制＂＜＜ decimalNumber ＜＜＂转换为十六进制为: ＂；while （！stackisEmpty(））｛std:：cout ＜＜ stackpop(）；｝std:：cout ＜＜ std:：endl;｝｀｀｀（五）主函数｀｀｀cppint main(）｛int decimalNumber;std:：cout ＜＜＂请输入一个十进制数: ＂；std:：cin ＞＞ decimalNumber; decimalToBinary(decimalNumber)；decimalToOctal(decimalNumber)；decimalToHexadecimal(decimalNumber)；return 0;｝｀｀｀五、实验结果与分析（一）实验结果输入十进制数 25，得到以下结果：二进制：11001八进制：31十六进制：19（二）结果分析通过实验，成功实现了将十进制数转换为二进制、八进制和十六进制。

数据结构栈的进制转换

数据结构栈的进制转换

实验三栈的基本操作的实现学号姓名班级：02宋旸10计本实验日期：2012 年 3 月28 日3.1 背景知识熟悉windows2000操作系统，具有一定的C程序设计语言基础，熟悉Turboc2环境。

3.2 实验目的理解栈的定义、组织形式、结构特征和类型说明以及在相应存储方式下实现的入栈、出栈和获取栈顶元素、判栈空等算法。

3.3 工具/准备工作提前编写好所要调试的程序。

3.4 实验内容与步骤1．将十进制数分别转换为八进制和二进制以及十六进制2．要求用栈实现。

3．验证各操作的正确性。

将十进制数20和98所对应的二进制，八进制和十六进制数分别进行输出。

4、小括号的匹配/* Note:Your choice is C IDE */#include"stdio.h"#include"string.h"#include"math.h"#include"limits.h"#include"stdlib.h"#include"malloc.h"#define TRUE 1#define OK 1#define FALSE 0#define ERROR 0#define INFEASIBLE -1typedef int Status;typedef int SElement;#define STACK_INIT_SIZE 10#define STACKINCREMENT 2typedef struct SqStack{SElement *base ;SElement *top ;int stacksize ;}SqStack;int InitStack (SqStack *S){(*S).base = (SElement *)malloc(STACK_INIT_SIZE *sizeof (SElement)) ;if (!(*S).base)exit (OVERFLOW);S->top=S->base;S->stacksize= STACK_INIT_SIZE;return OK;}int DestroyStack (SqStack *S){free (S->base);S->base = NULL;S->top = NULL;S->stacksize = 0;return OK;}int ClearStack(SqStack *S){S->top = S->base;return OK;}int StackEmpty(SqStack S)//判断sqstack 是否为空{if (S.top == S.base )return TRUE;elsereturn FALSE ;}int StackLength (SqStack S)//返回s的元素个数,即栈的长度{return S.top-S.base ;}int GetTop(SqStack S,int*e)//若栈不为空,用e返回s的栈顶元素,并返回ok{if (S.top > S.base ){*e=*(S.top-1);return OK;}else return ERROR;}int Push(SqStack *S,int e)//插入元素e为新的栈顶元素{if (S->top - S->base >= S->stacksize){S->base =(SElement *)realloc ((*S).base,((*S).stacksize +STACKINCREMENT * sizeof (SElement)));if (!S->base )exit (OVERFLOW);S->top = S->base + S->stacksize;S->stacksize += STACKINCREMENT;}*(S->top) = e;S->top ++;return OK;}int Pop(SqStack *S,int*e){/* 若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERROR */if((*S).top==(*S).base)return ERROR;*e=*--(*S).top;return OK;}int StackTraverse (SqStack S ,int (*visit)(int ))//{while (S.top > S.base )visit (*S.base ++ );printf ("\n");return OK;}void conversion8(SqStack s){unsigned n;int e;InitStack (&s);//初始化栈printf ("n(>=0)=");scanf ("%u",&n);while (n)//当n不为0{Push (&s,n%8);n=n/8;}while (!StackEmpty(s))//当栈不为空{Pop (&s,&e);printf ("%d",e);}printf ("\n");}void conversion2(SqStack s){unsigned n;int e;InitStack (&s);//初始化栈printf ("n(>=0)=");scanf ("%u",&n);while (n)//当n不为0{Push (&s,n%2);n=n/2;}while (!StackEmpty(s))//当栈不为空{Pop (&s,&e);printf ("%d",e);}printf ("\n");}void conversion16(SqStack s){unsigned n;char d;int e;InitStack (&s);//初始化栈printf ("n(>=0)=");scanf ("%u",&n);while (n)//当n不为0{Push (&s,n%2);n=n/2;}while (!StackEmpty(s))//当栈不为空{Pop (&s,&e);switch(e){case 0:e=0;printf("%d",e);break;case 1:e=1;printf("%d",e);break;case 2:e=2;printf("%d",e);break;case 3:e=3;printf("%d",e);break;case 4:e=4;printf("%d",e);break;case 5:e=5;printf("%d",e);break;case 6:e=6;printf("%d",e);break;case 7:e=7;printf("%d",e);break;case 8:e=8;printf("%d",e);break;case 9:e=9;printf("%d",e);break;case 10:d='a';printf("%c",d);break;case 11:d='b';printf("%c",d);break;case 12:d='c';printf("%c",d);break;case 13:d='d';printf("%c",d);break;case 14:d='e';printf("%c",d);break;case 15:d='f';printf("%c",d);break;}printf ("%d",e);}printf ("\n");}//选择int choose(){int d;printf("请选择你要进行的进制的转换：\n");printf("如果是十进制转换为八进制请选择1\n");printf("如果是十进制转换为二进制请选择2\n");printf("如果是十进制转换为十六进制请选择3\n");printf("如果您想全部转换请选择9\n");printf("如果想退出请选择0\n");printf("\n");scanf("%d",&d);return d;}void main(){int f=0;SqStack s;while(!f){switch(choose()){case 1:conversion8(s);break;case 2:conversion2(s);break;case 3:conversion16(s);break;case 9:conversion8(s);conversion2(s);conversion16(s);break;case 0: f=-1;default: f=1;}}}3.5 实验总结通过查资料等手段，将这个进制转换的程序终于弄了出来，虽然费了很多的功夫，但是还是从中学到了很多。

数据结构实验二：利用栈把十进制数转换为八进制数

数据结构实验二：利用栈把十进制数转换为八进制数

数据结构实验⼆：利⽤栈把⼗进制数转换为⼋进制数#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);}程序运⾏结果如下：可以发现，⽆论是正数还是负数程序都能进⾏转化。

栈的应用进制转换实验原理

栈的应用进制转换实验原理

栈的应用：进制转换实验原理1. 引言进制转换是计算机科学中重要的基础知识之一。

在日常生活中，我们经常会遇到需要将一个数值从一种进制转换为另一种进制的情况，比如将十进制数转换为二进制数或十六进制数。

在计算机系统中，进制转换也是非常常见的操作，特别是在数据存储和传输方面。

本文将介绍一种利用栈数据结构进行进制转换的实验原理。

栈是一种后进先出（LIFO）的数据结构，非常适合处理进制转换这类需要按照逆序处理的问题。

2. 实验原理进制转换的基本原理是不断地将一个数值除以目标进制的基数，并将余数保存在栈中，直到商为0为止。

然后从栈中依次取出余数构成转换后的数值。

以下是进制转换实验的基本原理步骤：2.1 准备工作首先，我们需要准备一个空栈，用于临时保存余数。

2.2 输入初始数值和目标进制我们需要输入一个初始数值和目标进制。

初始数值可以是十进制、二进制、八进制或十六进制，目标进制可以是二进制、八进制、十进制或十六进制。

2.3 进制转换的具体步骤1.用初始数值除以目标进制的基数，得到商和余数。

2.将余数保存在栈中。

3.将商作为新的初始数值，重复步骤1直到商为0。

4.从栈中依次取出余数，将它们构成转换后的数值。

2.4 输出转换结果根据目标进制的不同，我们需要对转换结果进行相应的转换和输出。

例如，如果目标进制为二进制，我们需要将十进制转换结果转换为二进制表示法。

3. 实验示例下面以将十进制数转换为二进制数的实验为例，演示栈在进制转换中的应用。

3.1 准备工作首先，我们准备一个空栈。

3.2 输入初始数值和目标进制假设我们要将十进制数42转换为二进制数。

3.3 进制转换的具体步骤1.将42除以2，得到商21和余数0。

2.将余数0保存在栈中。

3.将商21作为新的初始数值。

4.将21除以2，得到商10和余数1。

5.将余数1保存在栈中。

6.将商10作为新的初始数值。

7.重复步骤4至步骤6。

8.最终商为0，退出循环。

3.4 输出转换结果将栈中的余数依次取出，即可得到二进制数101010。

关于栈的实验报告

关于栈的实验报告

关于栈的实验报告引言栈（Stack）是一种常用的数据结构，它基于后进先出（Last In First Out，LIFO）的原则，元素的插入和删除操作只能在栈顶进行。

栈具有快速插入和删除元素的特点，因此在很多应用中广泛使用。

本实验旨在通过编写一个栈的实现，探究栈的基本操作以及应用，并对栈的性能进行评估。

一、栈的实现1. 栈的定义使用数组来实现一个基本的栈结构，可以定义一个栈类`Stack`，其中包含以下属性和方法：- 属性：- `max_size`：栈的最大容量- `top`：栈顶指针- `data`：存储栈元素的数组- 方法：- `__init__(self, size)`：构造函数，初始化栈对象，参数为栈的最大容量- `is_empty(self)`：判断栈是否为空- `is_full(self)`：判断栈是否已满- `push(self, item)`：将元素压入栈顶- `pop(self)`：从栈顶弹出一个元素- `peek(self)`：返回栈顶元素- `size(self)`：返回栈的当前大小- `clear(self)`：清空栈中所有元素2. 栈的实现pythonclass Stack:def __init__(self, size):self.max_size = sizeself.top = -1self.data = [None] * sizedef is_empty(self):return self.top == -1def is_full(self):return self.top == self.max_size - 1 def push(self, item):if self.is_full():print("Stack is full.")returnself.top += 1self.data[self.top] = itemdef pop(self):if self.is_empty():print("Stack is empty.")return Noneitem = self.data[self.top]self.top -= 1return itemdef peek(self):if self.is_empty():print("Stack is empty.")return Nonereturn self.data[self.top]def size(self):return self.top + 1def clear(self):self.top = -1上述代码实现了一个基本的栈，其中使用一个列表`data` 来存储栈的元素，`top` 表示栈顶指针，初始值为-1。

数据结构实验报告 栈进制转换

数据结构实验报告 栈进制转换

数据结构试验报告栈的应用——进制转换程序int Pop(Stack *s , int *e){if(s->top == s->base){return ERROR;}*e = * -- s->top;return OK;}4.主函数与进制转化void main(){int N;int a;int e;Stack s;InitStack(&s);Pop(&s , &e);Push(&s ,&e);InitStack(&s);printf("请输入十进制数：");scanf("%d",&N);printf("要将N转化为几进制？");scanf("%d",&a);while(N){e=N%a;Push( &s , &e );N = N / a ;}while(s.base!=s.top){Pop(&s ,&e);printf("%d",e);}free(s.base);system("pause");}3.源程序#include <stdio.h>#include<malloc.h>#include<stdlib.h>#define STACK_INIT_SIZE 100#define STACKINCREMENT 10#define OK 1#define ERROR 0#define OVERFLOW -1#define TRUE 1#define FALSE -1typedef struct{int *base;int *top;int stacksize;}Stack;int InitStack(Stack *s){s->base=(int *)malloc(STACK_INIT_SIZE * sizeof(int));if(!s->base){exit(OVERFLOW);}s->top=s->base;s->stacksize=STACK_INIT_SIZE;return OK;}int Push(Stack *s , int *e){if(s->top - s->base >= STACK_INIT_SIZE){s->base=(int *)realloc(s->base , (s->stacksize + STACKINCREMENT) * sizeof(int) );if(!s->base){exit(OVERFLOW);}s->top=s->base + STACKINCREMENT;}* s->top ++ = *e;return OK;}int Pop(Stack *s , int *e){if(s->top == s->base){return ERROR;}*e = * -- s->top;return OK;}void main(){int N;int a;int e;Stack s;InitStack(&s);Pop(&s , &e);Push(&s ,&e);InitStack(&s);printf("请输入十进制数：");scanf("%d",&N);printf("要将N转化为几进制？");scanf("%d",&a);while(N){e=N%a;Push( &s , &e );N = N / a ;}while(s.base!=s.top){Pop(&s ,&e);printf("%d",e);}free(s.base);system("pause");}调试与体会1.调试结果2.体会这次数据结构作业我选择了做进制转换，首先我觉得这个比较有实际意义，其次我觉得做迷宫比较难。

数据结构栈实验报告

数据结构栈实验报告

一、实验目的本次实验旨在帮助学生掌握栈的基本概念、特点、逻辑结构以及抽象数据类型，熟练运用顺序栈和链栈进行基本操作，理解递归算法中栈的状态变化，并学会在计算机科学中应用栈解决实际问题。

二、实验内容1. 实现顺序栈和链栈的结构类型定义、特点以及基本操作的实现。

2. 编写算法判断给定字符序列是否为回文。

3. 设计算法，利用栈操作将指定栈中的内容进行逆转。

4. 实现求解整数数组最大值的递归算法。

5. 分析实验过程中遇到的问题及解决方法。

三、实验步骤1. 实现顺序栈和链栈（1）顺序栈顺序栈使用数组实现，具有以下特点：- 存储空间固定，栈的大小预先定义。

- 栈顶指针指示栈顶元素的位置。

- 入栈和出栈操作都在栈顶进行。

- 当栈满时，无法继续入栈。

- 当栈空时，无法继续出栈。

（2）链栈链栈使用链表实现，具有以下特点：- 栈的大小可变，不受存储空间限制。

- 栈顶指针指向栈顶元素的前一个节点。

- 入栈和出栈操作的时间复杂度为O(1)。

- 不存在栈满或栈空的情况。

2. 编写算法判断字符序列是否为回文（1）创建一个空栈。

（2）遍历字符序列，将每个字符依次入栈。

（3）遍历字符序列，将每个字符依次出栈，并判断出栈的字符是否与原序列中的字符相同。

（4）若所有字符均相同，则字符序列为回文；否则，不是回文。

3. 设计算法，利用栈操作将指定栈中的内容进行逆转（1）创建一个空栈。

（2）遍历原栈，将每个元素依次出栈，并判断栈是否为空。

（3）若栈不为空，则将出栈的元素依次入栈。

（4）当原栈为空时，将新栈中的元素依次出栈，实现栈内容的逆转。

4. 实现求解整数数组最大值的递归算法（1）定义一个递归函数，用于求解数组中最大值。

（2）在递归函数中，比较当前元素与左右子数组中的最大值。

（3）返回最大值。

5. 分析实验过程中遇到的问题及解决方法（1）问题：顺序栈在栈满时无法继续入栈。

解决方法：在入栈操作前，判断栈的大小是否已满。

若已满，则提示用户栈已满，无法继续入栈。

数制转换（栈应用）实验报告

数制转换（栈应用）实验报告

数制转换（栈应用）实验报告实验报告1．实验题目运用栈进行数制转换。

2．需求分析用C编写完成：对于输入的任意一个非负十进制整数，输出与其等值的其他进制数。

3．概要设计由于运行过程是从低位到高位顺序产生进制数的各个数位，而输出应从高位到底位进行，这和计算过程相反，恰好可以运用栈把进制数的各位顺序入栈，而按出栈序列输出，即为对应转换的进制数。

4．详细设计1)先对栈定义:Typedef struct{SElemType *base;SElemType *top;int stacksize;}Stack;2)构造一个栈：int InitStack(Stack &S)//初始化栈{S.base=(SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));if(!S.base) exit (ERROR); //存储分配失败S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}3)分别进行入栈和出栈操作，再进行进制转换。

5．调试分析#include#include#define STACK_INIT_SIZE 100#define STACKINCREMENT 10#define OK 1#define ERROR 0//栈定义typedef struct{int *base;int *top;int stacksize;}Stack;int InitStack(Stack &S)//初始化栈{S.base=(int *)malloc(STACK_INIT_SIZE * sizeof(int));if(!S.base) exit (ERROR); //存储分配失败S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}int push(Stack &S,int e)//入栈{if(S.top-S.base>=S.stacksize) //栈满{S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREMENT)* sizeof(int));if(!S.base) exit (ERROR); //存储分配失败S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return 1;}int pop(Stack &S,int &e)//出栈{if(S.top==S.base) return ERROR;//栈空e=* --S.top;return OK;}void conversion(int n,int m)//n为十进制数，m为要转换进制{Stack S;InitStack(S);while(n!=0){push(S,n%m);n=n/m;}while(S.top!=S.base){int x;pop(S,x);printf("%x",x);}}int main(){int n,m;printf("请输入一个十进制正整数:");scanf("%d",&n);printf("\n输入要转换进制:");scanf("%d",&m);if(m<2){printf("输入不合法!请输入大于1的进制！"); printf("\n");return ERROR;}conversion(n,m);printf("\n");return OK;}。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

数据结构试验报告栈的应用——进制转换程序
if(s->top - s->base >= STACK_INIT_SIZE)
{
s->base=(int *)realloc(s->base , (s->stacksize + STACKINCREMENT) * sizeof(int) );
if(!s->base)
{
exit(OVERFLOW);
}
s->top=s->base + STACKINCREMENT;
}
* s->top ++ = *e;
return OK;
}
3.出栈程序
int Pop(Stack *s , int *e)
{
if(s->top == s->base)
{
return ERROR;
}
*e = * -- s->top;
return OK;
}
4.主函数与进制转化
void main()
{
int N;
int a;
int e;
Stack s;
InitStack(&s);
Pop(&s , &e);
Push(&s ,&e);
InitStack(&s);
printf("请输入十进制数：");
scanf("%d",&N);
printf("要将N转化为几进制");
scanf("%d",&a);
while(N)
{
e=N%a;
Push( &s , &e );
N = N / a ;
}
int *base;
int *top;
int stacksize;
}Stack;
int InitStack(Stack *s)
{
s->base=(int *)malloc(STACK_INIT_SIZE * sizeof(int));
if(!s->base)
{
exit(OVERFLOW);
}
s->top=s->base;
s->stacksize=STACK_INIT_SIZE;
return OK;
}
int Push(Stack *s , int *e)
{
if(s->top - s->base >= STACK_INIT_SIZE)
{
s->base=(int *)realloc(s->base , (s->stacksize + STACKINCREMENT) * sizeof(int) );
if(!s->base)
{
exit(OVERFLOW);
}
s->top=s->base + STACKINCREMENT;
}
* s->top ++ = *e;
return OK;
}
int Pop(Stack *s , int *e)
{
if(s->top == s->base)
{
return ERROR;
}
*e = * -- s->top;
return OK;
}
void main()
{
int N;
int a;
int e;
Stack s;
InitStack(&s);
Pop(&s , &e);
Push(&s ,&e);
InitStack(&s);
printf("请输入十进制数：");
scanf("%d",&N);
printf("要将N转化为几进制");
scanf("%d",&a);
while(N)
{
e=N%a;
Push( &s , &e );
N = N / a ;
}
while!=
{
Pop(&s ,&e);
printf("%d",e);
}
free;
system("pause"); }
调试与体会
1.调试结果
2.体会
这次数据结构作业我选择了做进制转换，首先我觉得这个比较有实际意义，其次我觉得做迷宫比较难。

这次主要是学习如何用栈，栈自动分配变量，以及函数调用时所使用的一些空间。

通过编写这次程序，提高了对栈的理解，自我查找与学习交流能力，这次编写程序，自己通过结合课本知识编写了出来。

但是这次暴露出自己函数调用还是有一些问题的，通过同学的帮忙解决了很小但很严重的一个问题。

这次，我对数据结构和C语言也有了更多地理解。

相关文档
最新文档