用顺序栈实现进制转换

合集下载

c语言各进制转换方法

c语言各进制转换方法

二进制,八进制,十进制,十六进制之间的转换算法一、十进制与二进制之间的转换(1)十进制转换为二进制,分为整数部分和小数部分①整数部分方法:除2取余法,即每次将整数部分除以2,余数为该位权上的数,而商继续除以2,余数又为上一个位权上的数,这个步骤一直持续下去,直到商为0为止,最后读数时候,从最后一个余数读起,一直到最前面的一个余数。

下面举例:例:将十进制的168转换为二进制得出结果将十进制的168转换为二进制,(10101000)2分析:第一步,将168除以2,商84,余数为0。

第二步,将商84除以2,商42余数为0。

第三步,将商42除以2,商21余数为0。

第四步,将商21除以2,商10余数为1。

第五步,将商10除以2,商5余数为0。

第六步,将商5除以2,商2余数为1。

第七步,将商2除以2,商1余数为0。

第八步,将商1除以2,商0余数为1。

第九步,读数,因为最后一位是经过多次除以2才得到的,因此它是最高位,读数字从最后的余数向前读,即10101000(2)小数部分方法:乘2取整法,即将小数部分乘以2,然后取整数部分,剩下的小数部分继续乘以2,然后取整数部分,剩下的小数部分又乘以2,一直取到小数部分为零为止。

如果永远不能为零,就同十进制数的四舍五入一样,按照要求保留多少位小数时,就根据后面一位是0还是1,取舍,如果是零,舍掉,如果是1,向入一位。

换句话说就是0舍1入。

读数要从前面的整数读到后面的整数,下面举例:例1:将0.125换算为二进制得出结果:将0.125换算为二进制(0.001)2分析:第一步,将0.125乘以2,得0.25,则整数部分为0,小数部分为0.25;第二步, 将小数部分0.25乘以2,得0.5,则整数部分为0,小数部分为0.5;第三步, 将小数部分0.5乘以2,得1.0,则整数部分为1,小数部分为0.0;第四步,读数,从第一位读起,读到最后一位,即为0.001。

例2,将0.45转换为二进制(保留到小数点第四位)大家从上面步骤可以看出,当第五次做乘法时候,得到的结果是0.4,那么小数部分继续乘以2,得0.8,0.8又乘以2的,到1.6这样一直乘下去,最后不可能得到小数部分为零,因此,这个时候只好学习十进制的方法进行四舍五入了,但是二进制只有0和1两个,于是就出现0舍1入。

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

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

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

二、实验原理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.本实验的结果表明,转换程序能够正确地将十进制数转换为目标进制数,并且具有较高的效率。

十进制转二进制(顺序栈设计和应用)

十进制转二进制(顺序栈设计和应用)

⼗进制转⼆进制(顺序栈设计和应⽤)设计⼀个顺序栈,并利⽤该顺序栈将给定的⼗进制整整数转换为⼆进制并输出。

函数接⼝定义:#define MaxSize 100 /* 栈最⼤容量 */int top; /* 栈顶指针 */int mystack[MaxSize]; /* 顺序栈 *//*判栈是否为空,空返回true,⾮空返回false */bool isEmpty();/* 元素x⼊栈 */void Push(int x);/* 取栈顶元素 */int getTop();/* 删除栈顶元素 */void Pop();其中 MaxSize 和 top 分别为栈的最⼤容量和栈顶指针。

数组mystack ⽤来模拟顺序栈。

请实现给出的isEmpty、Push、getTop和Pop这四个函数。

裁判测试程序样例:#include <bits/stdc++.h>using namespace std;#define MaxSize 100 /* 栈最⼤容量 */int top; /* 栈顶指针 */int mystack[MaxSize]; /* 顺序栈 *//*判栈是否为空,空返回true,⾮空返回false */bool isEmpty();/* 元素x⼊栈 */void Push(int x);/* 取栈顶元素 */int getTop();/* 删除栈顶元素 */void Pop();/* ⼗进制正整数转换为⼆进制 */void dec2bin(int x) {top = -1; /* 初始化栈顶指针 */while (x) {Push(x % 2);x >>= 1;}while (!isEmpty()) {int t = getTop();Pop();printf("%d", t);}printf("\n");}int main(int argc, char const *argv[]){int n;while (scanf("%d", &n) != EOF) {dec2bin(n);}return 0;}/* 请在这⾥填写答案 */输⼊样例:10结尾⽆空⾏输出样例:1010结尾⽆空⾏Answer/*判栈是否为空,空返回true,⾮空返回false */bool isEmpty() {if(top == -1)//如果栈顶指针是-1则没有元素为空return true;elsereturn false;};/* 元素x⼊栈 */void Push(int x) {if(top+1 > MaxSize) {//栈顶指针是指向栈顶元素上⼀个位置,则只要栈顶指针+1⼤于顺序栈数组最⼤数则栈满 printf("栈已满!");return;}if(top == -1) {mystack[++top] = x;//如果是空栈,需要让栈顶指针先加⼀指向0,再⼊栈top++;//栈顶指针是指向栈顶元素上⼀个位置,则还需要再加⼀}else{mystack[top++] = x;//其他情况则只⽤先⼊栈后,栈顶指针再加⼀即可}};/* 取栈顶元素 */int getTop() {return mystack[top-1];//栈顶指针减⼀的位置即为栈顶元素};/* 删除栈顶元素 */void Pop() {if(top == 1)top = -1;//如果只剩⼀个元素,只⽤让栈顶指针为-1即可elsetop--;//其他情况只要栈顶指针减⼀即可};。

利用栈实现数制转换(10进制转换8进制)

利用栈实现数制转换(10进制转换8进制)

利用栈实现数制转换(10进制转换8进制)//利用栈实现数制转换(10进制转换8进制)#include#include#define ERROR 0#define OK 1#define STACK_INIT_SIZE 100 //存储空间初始分配量#define STACKINCREMENT 10 //存储空间分配增量typedef int SElemType;typedef struct stack{SElemType *top;SElemType *bottom;int stacksize;}SqStack;int InitStack(SqStack *S){//构造一个空栈S->bottom=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SEl emType));if(!S->bottom) return ERROR; //存储分配失败S->top=S->bottom;S->stacksize=STACK_INIT_SIZE;return OK;} //InitStackint Push(SqStack *S,SElemType e){//插入元素e为新的栈顶元素if(S->top-S->bottom>=S->stacksize-1){S->bottom=(SElemType*)realloc(S->bottom,(S->stacksize+STACKINCREMENT)*sizeof(SElemType));if(!S->bottom)return ERROR; //S->top=S->bottom+S->stacksize;}*S->top++=e;return OK;} //Pushint Pop(SqStack *S,SElemType *e){//若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERROR;if(S->top==S->bottom)return ERROR;*e=*--S->top;return OK;} //Popint StackEmpty(SqStack S){if(S.top==S.bottom)return 1;else return 0;}void main(){SqStack myStack;int N,e;InitStack(&myStack);printf("请输入N:");scanf("%d",&N);while(N){Push(&myStack,N%8);N=N/8;}while(!StackEmpty(myStack)) {Pop(&myStack,&e);printf("%d",e);}printf("\n");}上一页下一页。

c语言_各种进制转换

c语言_各种进制转换

c语言各种进制转换计算机中常用的数的进制主要有:二进制、八进制、十六进制。

2进制,用两个阿拉伯数字:0、1;8进制,用八个阿拉伯数字:0、1、2、3、4、5、6、7;10进制,用十个阿拉伯数字:0到9;16进制就是逢16进1,但我们只有0~9这十个数字,所以我们用A,B,C,D,E,F这五个字母来分别表示10,11,12,13,14,15。

字母不区分大小写。

以下简介各种进制之间的转换方法:一、二进制转换十进制例:二进制“1101100”1101100 ←二进制数6543210 ←排位方法例如二进制换算十进制的算法:1*26 + 1*25 + 0*24 + 1*23 + 1* 22 + 0*21 + 0*20↑ ↑说明:2代表进制,后面的数是次方(从右往左数,以0开始)=64+32+0+8+4+0+0=108二、二进制换算八进制例:二进制的“10110111011”换八进制时,从右到左,三位一组,不够补0,即成了:010 110 111 011然后每组中的3个数分别对应4、2、1的状态,然后将为状态为1的相加,如:010 = 2110 = 4+2 = 6111 = 4+2+1 = 7011 = 2+1 = 3结果为:2673三、二进制转换十六进制十六进制换二进制的方法也类似,只要每组4位,分别对应8、4、2、1就行了,如分解为:0101 1011 1011运算为:0101 = 4+1 = 51011 = 8+2+1 = 11(由于10为A,所以11即B)1011 = 8+2+1 = 11(由于10为A,所以11即B)结果为:5BB四、二进制数转换为十进制数二进制数第0位的权值是2的0次方,第1位的权值是2的1次方……所以,设有一个二进制数:0110 0100,转换为10进制为:计算:0 * 20 + 0 * 21 + 1 * 22 + 0 * 23 + 0 * 24 + 1 * 25 + 1 * 26 + 0 * 27 = 100五、八进制数转换为十进制数八进制就是逢8进1。

实验二栈与队列操作实验题目

实验二栈与队列操作实验题目

实验二栈与队列操作实验题目实验二栈与队列操作实验目的:(1)理解栈与队列的结构特征和运算特征,以便在实际问题背景下灵活运用。

(2)了解复杂问题的递归算法设计。

本次实验中,下列实验项目选做一。

1、顺序栈的基本操作[问题描述]设计算法,实现顺序栈的各种基本操作[基本要求](1)初始化栈s。

(2)从键盘输入10个字符以$结束,建立顺序栈。

(3)从键盘输入1个元素,执行入栈操作。

(4)将栈顶元素出栈。

(5)判断栈是否为空。

(6)输出从栈顶到栈底元素。

要求程序通过一个主菜单进行控制,在主菜单界面通过选择菜单项的序号来调用各功能函数。

2、链栈的基本操作[问题描述]设计算法,实现链栈的各种基本操作[基本要求](1)初始化栈s。

(2)从键盘输入10个字符以$结束,建立带头结点的链栈。

(3)从键盘输入1个元素,执行入栈操作。

(4)完成出栈操作。

(5)判断栈是否为空。

(6)输出从栈顶到栈底元素。

(7)输出链栈的长度。

要求程序通过一个主菜单进行控制,在主菜单界面通过选择菜单项的序号来调用各功能函数。

3、循环队列的基本操作[问题描述]设计算法,实现循环顺序队列的建立、入队、出队等操作。

[基本要求](1)从键盘输入10个字符以$结束,建立循环队列,并显示结果。

(2)从键盘输入1个元素,执行入队操作,并显示结果。

(3)将队头元素出队,并显示结果。

(4)要求程序通过一个主菜单进行控制,在主菜单界面通过选择菜单项的序号来调用各功能函数。

4、只用尾指针表示的循环链表队列的综合操作[问题描述]假设以带头结点的的循环链表表示队列,并且只设一个指针指向队尾元素的结点(注意不设头指针),试编写队列初始化、入队、出队函数。

[基本要求及提示](1)首先定义链表结点类型。

(2)编写带头结点的循环链表的初始化函数,只用尾指针表示。

(3)编写入队函数、出队函数。

(4)在主函数中编写菜单(1.初始化;2.入队;3.出队;4.退出),调用上述功能函数。

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

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

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

二、实验环境操作系统: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(二)结果分析通过实验,成功实现了将十进制数转换为二进制、八进制和十六进制。

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

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

数据结构栈和队列实验报告南京信息⼯程⼤学实验(实习)报告实验(实习)名称栈和队列⽇期2017.11.8 得分指导⽼师崔萌萌系计算机系专业软件⼯程年级2016 班次(1) 姓名学号⼀、实验⽬的1、学习栈的顺序存储和实现,会进⾏栈的基本操作2、掌握递归3、学习队列的顺序存储、链式存储,会进⾏队列的基本操作4、掌握循环队列的表⽰和基本操作⼆、实验内容1、⽤栈解决以下问题:(1)对于输⼊的任意⼀个⾮负⼗进制数,显⽰输出与其等值的⼋进制数,写出程序。

(2)表达式求值,写出程序。

2、⽤递归写出以下程序:(1)求n!。

(2)汉诺塔程序,并截图显⽰3、4、5个盘⼦的移动步骤,写出移动6个盘⼦的移动次数。

3、编程实现:(1)创建队列,将asdfghjkl依次⼊队。

(2)将队列asdfghjkl依次出队。

4、编程实现创建⼀个最多6个元素的循环队列、将ABCDEF依次⼊队,判断循环队列是否队满。

三、实验步骤1.栈的使⽤1.1 ⽤栈实现进制的转换:代码如下:#include#includeusing namespace std;int main(){stack s; //栈s;int n,radix;printf("请输⼊要转换的⼗进制⾮负整数: ");scanf("%d",&n);printf("请输⼊⽬标进制: ");scanf("%d",&radix);printf("转换为%d进制: ",radix);while(n) {s.push(n%radix);n /= radix;}while(!s.empty()) { //⾮空printf("%d",s.top());s.pop();}printf("\n");return 0;}运⾏结果如下:2.2 求表达式的值代码如下:#include#include#include#include#define true 1#define false 0#define OPSETSIZE 8typedef int Status;unsigned char Prior[8][8] = { //运算符优先级表// '+' '-' '*' '/' '(' ')' '#' '^'/*'+'*/ '>','>','<','<','<','>','>','<',/*'-'*/ '>','>','<','<','<','>','>','<',/*'*'*/ '>','>','>','>','<','>','>','<',/*'/'*/ '>','>','>','>','<','>','>','<',/*'('*/ '<','<','<','<','<','=',' ','<',/*')'*/ '>','>','>','>',' ','>','>','>',/*'#'*/ '<','<','<','<','<',' ','=','<',/*'^'*/ '>','>','>','>','<','>','>','>'};typedef struct StackChar { //StackChar类型的结点SC char c;struct StackChar *next;}SC;struct StackFloat *next;}SF;SC* Push(SC* s,char c) //SC类型的指针Push,返回p{SC* p = (SC* )malloc(sizeof(SC));p->c = c;p->next = s;return p;}SF* Push(SF* s,float f) //SF类型的指针Push,返回p{SF* p = (SF* )malloc(sizeof(SF));p->f = f;p->next = s;return p;}SC* Pop(SC* s) //SC类型的指针Pop{SC* q = s;s = s->next;free(q);return s;}SF* Pop(SF* s) //SF类型的指针Pop{SF* q = s;s = s->next;free(q);return s;}float Operate(float a,unsigned char theta, float b) //计算函数Operate { switch(theta){case '+': return a+b;case '-': return a-b;case '*': return a*b;case '/': return a/b;case '^': return pow(a,b);default : return 0;}char OPSET[OPSETSIZE] = {'+','-','*','/','(',')','#','^'};Status In(char Test,char *TestOp){int Find = false;for (int i=0; i< OPSETSIZE; i++) {if(Test == TestOp[i]) Find = true;}return Find;}Status ReturnOpOrd(char op,char *TestOp){for(int i=0; iif(op == TestOp[i]) return i;}}char precede(char Aop, char Bop){return Prior[ReturnOpOrd(Aop,OPSET)][ReturnOpOrd(Bop,OPSET)];}float EvaluateExpression(char* MyExpression)//表达式的运算符优先算法{//OPTR和OPND分别为运算符栈和运算数栈,OP为运算符集合SC* OPTR = NULL; //运算符栈,字符元素SF* OPND = NULL; //运算数栈,实数元素char TempData[20];float Data,a,b;char theta, *c, Dr[] = {'#','\0'};OPTR = Push(OPTR,'#');c = strcat(MyExpression,Dr);strcpy(TempData,"\0"); //字符串拷贝函数while (*c != '#' || OPTR->c != '#') {if (!In(*c, OPSET)) {Dr[0] = *c;strcat(TempData,Dr); //字符串连接函数c++;if (In(*c, OPSET)) {Data = atof(TempData); //字符串转换函数(double) OPND = Push(OPND, Data); strcpy(TempData,"\0");}} else { //不是运算符则进栈switch (precede(OPTR->c, *c))case '<': //栈顶元素优先级低OPTR=Push(OPTR, *c); c++; break;case '=': //去括号并接收下⼀字符OPTR = Pop(OPTR); c++; break;case '>': //退栈并将运算结果⼊栈theta = OPTR->c; OPTR = Pop(OPTR);b = OPND->f; OPND = Pop(OPND);a = OPND->f; OPND = Pop(OPND);OPND = Push(OPND, Operate(a, theta, b)); break;}}}return OPND->f;}int main(){char s[128];printf("请输⼊表达式: \n");scanf("%s",s);printf("该表达式的值为: \n");printf("%s = ",s);printf("%g\n",EvaluateExpression(s)); // %g return 0; }运⾏结果如下:2.递归的使⽤2.1 求n!:代码如下:#includeint Fact(int n){if(0 == n) return 1;else return n*Fact(n-1);}{int n;scanf("%d",&n);printf("%d的阶乘为:",n);printf("%d",Fact(n));return 0;}运⾏结果如下:2.2 哈诺塔:代码如下:#includeint Hanoi(int n,char a,char b,char c) { if(1 == n)printf("%c-%d->%c ",a,1,c);else{Hanoi(n-1,a,c,b);printf("%c-%d->%c ",a,n,c);Hanoi(n-1,b,a,c);}return 0;}int main(){int n;char a='A',b='B',c='C';printf("请输⼊汉诺塔的层数: "); scanf("%d",&n);Hanoi(n,a,b,c);printf("\n");return 0;}运⾏结果如下:n=3时n=4时n=5时n=6时由3,4,5可推知n 层哈诺塔需要移动 12 n次;n=6时,需要移动63次。

十进制转化为二进制栈代码c语言

十进制转化为二进制栈代码c语言

十进制转化为二进制栈代码c语言本文介绍如何使用栈实现将十进制数字转化为二进制数字的代码,使用的编程语言是C语言。

首先,需要定义一个栈的结构体,包括栈顶指针和栈的大小: ```#define MAX_STACK_SIZE 100typedef struct {int top;int data[MAX_STACK_SIZE];} Stack;```然后,需要实现几个基本的栈操作函数,包括入栈、出栈、判断栈是否为空等:```Stack* create_stack() {Stack* stack = (Stack*) malloc(sizeof(Stack));stack->top = -1;return stack;}int is_empty(Stack* stack) {return stack->top == -1;}void push(Stack* stack, int data) {if (stack->top == MAX_STACK_SIZE - 1) {printf('Error: Stack overflow');return;}stack->top++;stack->data[stack->top] = data;}int pop(Stack* stack) {if (is_empty(stack)) {printf('Error: Stack is empty');return -1;}int data = stack->data[stack->top];stack->top--;return data;}```接下来,实现将十进制数字转化为二进制数字的函数,使用栈来存储每一位的二进制数字:```void decimal_to_binary(int decimal) { Stack* stack = create_stack();while (decimal > 0) {int remainder = decimal % 2;push(stack, remainder);decimal /= 2;}while (!is_empty(stack)) {int binary = pop(stack);printf('%d', binary);}}```最后,测试一下上述代码的运行情况:```int main() {int decimal = 10;decimal_to_binary(decimal);return 0;}```输出结果为:1010,即十进制数字10转化为二进制数字为1010。

第二单元栈和队列 答案

第二单元栈和队列   答案
14.和顺序栈相比,链栈有一个比较明显的优势是A。
A.通常不会出现栈满的情况B.通常不会出现栈空的情况
C.插入操作更容易实现D.删除操作更容易实现
15.若一个顺序栈中元素为n个,做进栈运算时发生上溢,则说明该栈的最大容量为(B)。
A. n-1B. n C. n+1 D. n/2
16.允许对队列进行的操作有D。
6.栈的插入和删除只能在栈的栈顶进行,后进栈的元素必定先出栈,所以又把栈称为__LIFO表;队列的插入和删除运算分别在队列的两端进行,先进队列的元素必定先出队列,所以又把队列称为___FIFO__表。
7.设F和R分别表示顺序循环队列的头指针和尾指针,或F指向队头元素的前一个位置,R指向队尾元素则判断该循环队列为空的条件为F==R。
13.对于顺序存储结构的栈,在做入栈运算时应先判断栈是否栈满;在做出栈运算时应先判断栈是否空栈;当栈中元素为n个,做入栈运算时发生上溢,则说明该栈的最大容量为n个元素空间。
三、判断题(每题1分,共12分)
1.队列是一种插入和删除操作分别在表的两端进行的线性表,是一种先进后出的结构。(×)
2.不论是入队列操作还是入栈操作,在顺序存储结构上都需要考虑“溢出”情况。(√)
A.i B.n-i C.n-i+1 D.不确定
7.设计一个判别表达式中左、右括号是否配对出现的算法,采用D数据结构最佳。A.线性表的顺序存储结构B.队列C.线性表的链式存储结构D.栈
8.判定一个顺序栈st(最多元素为MaxSize)为满的条件是D。
A.st->top != -1 B.st->top == -1
Int fact(inrn 1;
Else return n*fact(n-1);
}

C语言顺序栈实现十进制转换为二进制,八进制,十六进制

C语言顺序栈实现十进制转换为二进制,八进制,十六进制

运转结果:代码:#include <stdio.h>#include <stdlib.h>#define MAX 20typedef struct {int data[MAX];int top;}SeqStack;SeqStack* Init(){SeqStack *s;s = (SeqStack *)malloc(sizeof(SeqStack));s->top = -1;return s;}void Destroy(SeqStack *s){free(s);}bool IsFull(SeqStack *s){return (s->top == MAX - 1) ? true :false;}bool IsEmpty(SeqStack *s){return (s->top == -1) ? true :false;}void Push(SeqStack *s, int a){if (IsFull(s)){printf("The stack is full, failed to push!\n");return;}s->top++;s->data[s->top] =a;}int Pop(SeqStack *s){int e;if (IsEmpty(s)){printf("The stack is empty, failed to pop!\n");return NULL;}e = s->data[s->top]; s->top--;return e;}int ReadTop(SeqStack *s){return s->data[s->top];}void Print(SeqStack *s){int temp = s->top;if (IsEmpty(s)){printf("The stack is empty!\n");return;}printf(" 变换后的结果 :\n");while (temp >= 0){if (s->data[temp]<10)printf("%d ", s->data[temp]);else {if (s->data[temp] = 10)printf("a");else if (s->data[temp] = 11)printf("b");else if (s->data[temp] = 12)printf("c");else if (s->data[temp] = 13)printf("d");else if (s->data[temp] = 14)printf("e");else printf("f");}temp--;}printf("\n");}int main(){int m,c,d,n;SeqStack *s;s = Init();}printf(" 请输入要变换的十进制数:");scanf("%d", &m);printf("\n");printf(" 请输入变换进制:\n");printf("******************************\n");printf("* 请选择一个你要变换的进制*\n"); printf("*1. 二进制 *\n");printf("*2. 八进制 *\n");printf("*3. 十六进制 *\n");printf("******************************\n"); scanf("%d",&d);printf("\n");if (d == 1)n = 2;else if (d == 2)n = 8;else if (d == 3)n = 16;else printf(" 输入有误! ");while (m){c =m%n;m = m / n;Push(s, c);}Print(s);Destroy(s);。

栈的应用-数制转换(C语言数据结构)

栈的应用-数制转换(C语言数据结构)

栈的应⽤-数制转换(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开关实现。

任务5 进位制转换

任务5 进位制转换
数据结构
网络课程
常州信息职业技术学院

教学目标
任 务 5
法 演
1、知识目标

1)掌握队列的定义及基本运算;
上 一
2)掌握循环队列、链队列基本运算的实现算
页 法。
进 下 2、能力目标

一 页
1)具有恰当的选择队列作为数据的逻辑结构、
循环队列、链队列作为数据的存储结构的能
制 返 力;
转 回 2)具有应用队列解决实际问题的能力。

一 页
义下的加1操作可以描述为:
①利用选择结构
循环队列示意图
制 返 if(i+1==QueueSize)//i为front或rear
回 i=0;

else

VC++
i++; ②利用模运算
i=(i+1)%QueueSize;//i为front或rear
9
算 3、循环队列边界条件的处理方法

法 演
循环队列中,由于入队时尾指针向前追赶头指
示队列满。 我们将使用此方法。
10
算 4、循环队列的描述
任 务 5
进 位 制 转
法 演 示
上 一 页
下 一 页
返 回
#tt5yyd、ppe④v{将}⑤D{下}eefDiii循DitQQoddCnnniaiQQQfeni尾的faeettt(ti--am入出d环(eQa---trff>>frctQ{a>>>QTarep指头EocsQfcuTp{队队o队cdrTauyrt=huouneepurynouoraeyp针 指aeQnuuuQa;utptneut②i{}③i{列uperus};tncnnraetue-tn;ue(=ee加针stD[E=ttt>D“eFrr/t-的eQ(;d(c判判/QQt(eemSd-队“auQ+eu队eaQi加1;tt-a队tirQeuum基luut+>paz-队队qtla⑥D{}空-(eerr中>a(Tte;r1u>C[p满nnyQuue[本①v{airQrye空满f;}1”Q取f(ieaeeet/元orQQ/up)r(Q/a/0u”trEFa/o)QQ/运i-计eeu尾]队T置头0--de{r)队>n)um素QQ=(;r{>>+;uu)yup)Ctlfn算I数x指;+e列lcc1eep--per队指u/头n(个/i>>;/oxooueuQS)1tetCr/定iy%器s定nxifcuuQ针tee元)i空针元/t-QQ(ir数(z%otiE/nn(r>“oC*u义Q]t新e0定uQ义tt定uu(素;m队定nd素QeQ]==0)等inuee;rtuua;队元/==p)/义,t=队ueu}uQ义个/空t义e/eD;=队t于auQ0队ee}eQuyu列素0[*Fae(;u列数”e(uQe-C;列tSQQe列rQ>aeu/元插o*S-ii/最/加Tu)u)rezr)/>队nQ元i;元/e队Q)eeyez/素入tf/*ae大队)Su1;(/pre列u素Qr计xC素o空ei;e=类e队/zi容nS满)i/tu无0xe个r数循定(t下i/Qe型];;尾0)z/量上;循元e)数器*环u义溢;时Q}e溢环素减u置意)队e意为10义*满Q义空下)

武汉理工数据结构实验2 栈和队列基本操作和应用

武汉理工数据结构实验2  栈和队列基本操作和应用

实验2 栈和队列的基本操作和应用1实验目的(1)熟练掌握顺序栈的基本操作。

(2)掌握顺序栈的应用。

(3)掌握顺序循环队列的基本操作。

(4)掌握链式队列的基本操作。

2实验内容(1)设计一个顺序栈的基本操作的演示程序;(2)利用顺序栈,进行整数的不同进制之间的转换;(3)设计一个顺序循环队列的基本操作演示程序;(4)设计一个链式队列的基本操作演示程序。

【基本要求】I.实验内容(1)的基本要求:编写一个程序,将一个顺序栈的元素依次取出,并打印其元素值。

II.实验内容(2)的基本要求:编写一个程序,将一个非负的十进制整数转换成二进制。

III.实验内容(3)的基本要求:编写一个程序,将一个顺序队列的元素依次取出,并打印其元素值。

IV.实验内容(4)的基本要求:编写一个程序,将一个链式队列的元素依次取出,并打印其元素值。

【测试数据】自定3实验结果按照学校实验格式要求撰写实验报告,内容主要包括1)实验目的;2)实验内容;3)实验环境和方法;4)实验过程描述;5)实验心得体会参考程序如下:实验内容(1)参考程序/*sqStack.h文件*/#define INIT_SIZE 100#define INCREMENT 10typedef int ElemType;//typedef char ElemType;typedef struct SqStack {ElemType *base;ElemType *top;int stacksize;}SqStack;enum Status{OK,ERROR,OVERFLOW};/*sqStackOp.h文件*/#include "sqStack.h"Status InitStack(SqStack &S) ;Status GetTop(SqStack S,ElemType &e);Status Push(SqStack &S,ElemType e);Status Pop(SqStack &S,ElemType &e);bool StackEmpty(SqStack &S);/*sqStackOp.cpp文件*/#include <malloc.h>#include <stdlib.h>#include "sqStackOp.h"Status InitStack(SqStack &S) {//构造一个空的栈S.base=(ElemType*)malloc(INIT_SIZE*sizeof(ElemType));if(! S.base) exit(OVERFLOW); //存储分配失败S.top=S.base;S.stacksize=INIT_SIZE;return OK;} //InitStackStatus GetTop(SqStack S,ElemType &e){//若栈不空,则用e返回S的栈顶元素,并返回OK;否则返回ERROR if(S.top==S.base) return ERROR;e=*(S.top-1);return OK;} //GetTopStatus Push(SqStack &S,ElemType e){//插入元素e为新的栈顶元素if(S.top-S.base>=S.stacksize){ //栈满,追加存储空间S.base=(ElemType *)realloc(S.base,(S.stacksize+INCREMENT)*sizeof(ElemType));if(!S.base)exit(OVERFLOW); //存储分配失败S.top=S.base+S.stacksize;S.stacksize+=INCREMENT;}*S.top++=e;return OK;} //PushStatus Pop(SqStack &S,ElemType &e){//若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERRORif(S.top==S.base) return ERROR;e=*(--S.top);return OK;} //Push//判断栈是否为空bool StackEmpty(SqStack &S){if(S.top == S.base)return true;elsereturn false;}/*main.cpp文件*/#include <stdio.h>#include <stdlib.h>#include "sqStackOp.h"void main(){printf("Hellow stack \n");SqStack S; //定义顺序栈Sif(OK != InitStack(S)) {printf("顺序栈初始化出错,退出....\n");exit(-1);}Push(S, 1);Push(S,2);Push(S,3);int e;Pop(S, e);printf("出栈元素= %d \n",e);Push(S,4);Push(S,5);while(!StackEmpty(S)){Pop(S, e);printf("出栈元素= %d \n",e);}/*SqStack S; char x,y;InitStack(S); x='c';y='k';Push(S,x); Push(S,'a'); Push(S,y);Pop(S,x); Push(S,'t'); Push(S,x);Pop(S,x); Push(S,'s');while(!StackEmpty(S)){ Pop(S,y);printf("%c ",y); };printf("%c ",x);*/getchar();}实验内容(2)参考程序/*sqStack.h文件*/#define INIT_SIZE 100#define INCREMENT 10typedef int ElemType;typedef struct SqStack {ElemType *base;ElemType *top;int stacksize;}SqStack;enum Status{OK,ERROR,OVERFLOW};/*sqStackOp.h文件*/#include "sqStack.h"Status InitStack(SqStack &S) ;Status GetTop(SqStack S,ElemType &e);Status Push(SqStack &S,ElemType e);Status Pop(SqStack &S,ElemType &e);bool StackEmpty(SqStack &S);/*sqStackOp.cpp文件*/#include <malloc.h>#include <stdlib.h>#include "sqStackOp.h"Status InitStack(SqStack &S) {//构造一个空的栈S.base=(ElemType*)malloc(INIT_SIZE*sizeof(ElemType));if(! S.base) exit(OVERFLOW); //存储分配失败S.top=S.base;S.stacksize=INIT_SIZE;return OK;} //InitStackStatus GetTop(SqStack S,ElemType &e){//若栈不空,则用e返回S的栈顶元素,并返回OK;否则返回ERRORif(S.top==S.base) return ERROR;e=*(S.top-1);return OK;} //GetTopStatus Push(SqStack &S,ElemType e){//插入元素e为新的栈顶元素if(S.top-S.base>=S.stacksize){ //栈满,追加存储空间S.base=(ElemType *)realloc(S.base,(S.stacksize+INCREMENT)*sizeof(ElemType));if(!S.base)exit(OVERFLOW); //存储分配失败S.top=S.base+S.stacksize;S.stacksize+=INCREMENT;}*S.top++=e;return OK;} //PushStatus Pop(SqStack &S,ElemType &e){//若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERRORif(S.top==S.base) return ERROR;e=*(--S.top);return OK;} //Push//判断栈是否为空bool StackEmpty(SqStack &S){if(S.top == S.base)return true;elsereturn false;}/*main.cpp文件*/#include <stdio.h>#include <stdlib.h>#include "sqStackOp.h"void main(){SqStack s;int x;InitStack(s);scanf("%d",&x); //%d--十进制输入;%O--八进制输入;%x--十六进制输入//修改这里输入进制和下面整除和余数计算,就可以获得其他进制的转换while(x!=0){Push(s,x%8);x=x/8;}while(!StackEmpty(s)){Pop(s,x);printf("%d ",x);}printf("\n");getchar();}实验内容(3)参考程序/*sqQueue.h 文件*/#define MAXQSIZE 100typedef int QElemType;typedef struct SqQueue {QElemType *base;int front;int rear;}SqQueue;enum Status{OK,ERROR,OVERFLOW};/*sqQueueOp.h 文件*/#include "sqQueue.h"Status InitQueue (SqQueue &Q) ;Status EnQueue (SqQueue &Q, QElemType e);Status DeQueue (SqQueue &Q, QElemType &e) ;bool QueueEmpty(SqQueue &Q);int QueueLength(SqQueue Q);/*sqQueueOp.cpp 文件*/#include <malloc.h>#include <stdlib.h>#include "sqQueueOp.h"Status InitQueue (SqQueue &Q) {// 构造一个空队列QQ.base = (QElemType *) malloc(MAXQSIZE *sizeof (QElemType));if (!Q.base) exit (OVERFLOW);// 存储分配失败Q.front = Q.rear = 0;return OK;}Status EnQueue (SqQueue &Q, QElemType e) { // 插入元素e为Q的新的队尾元素if ((Q.rear+1) % MAXQSIZE == Q.front)return ERROR; //队列满Q.base[Q.rear] = e;Q.rear = (Q.rear+1) % MAXQSIZE;return OK;}Status DeQueue (SqQueue &Q, QElemType &e) { // 若队列不空,则删除Q的队头元素,// 用e返回其值,并返回OK; 否则返回ERRORif (Q.front == Q.rear) return ERROR;e = Q.base[Q.front];Q.front = (Q.front+1) % MAXQSIZE;return OK;}//判断队列是否为空bool QueueEmpty(SqQueue &Q){if(Q.front== Q.rear)return true;elsereturn false;}//计算循环队列长度int QueueLength(SqQueue Q){return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;}/*main.cpp 文件*/#include <stdio.h>#include <stdlib.h>#include "sqQueueOp.h"void main(){printf("Hello Queue \n");SqQueue Q; //定义顺序队列QQElemType e;if(OK != InitQueue(Q)) {printf("顺序队列初始化出错,退出....\n");exit(-1);}EnQueue(Q,1);EnQueue(Q,3);EnQueue(Q,5);EnQueue(Q,7);printf("当前队列长度= %d \n",QueueLength(Q));DeQueue(Q,e);printf("队首元素%d出队,当前队列长度=%d\n",e,QueueLength(Q));EnQueue(Q,9);EnQueue(Q,11);while(!QueueEmpty(Q)){DeQueue(Q,e);printf("队首元素%d出队,当前队列长度=%d\n",e,QueueLength(Q));}getchar();}实验内容(4)参考程序/*linkQueue.h 文件*/typedef int QElemType;typedef struct QNode {// 结点类型QElemType data;struct QNode *next;} QNode, *QueuePtr;typedef struct { // 链队列类型QueuePtr front; // 队头指针QueuePtr rear; // 队尾指针} LinkQueue;enum Status{OK,ERROR,OVERFLOW};/*linkQueueOp.h 文件*/#include "linkQueue.h"Status InitQueue (LinkQueue &Q) ;Status EnQueue (LinkQueue &Q, QElemType e); Status DeQueue (LinkQueue &Q, QElemType &e) ; bool QueueEmpty(LinkQueue &Q);/*linkQueueOp.cpp 文件*/#include <malloc.h>#include <stdlib.h>#include "linkQueueOp.h"Status InitQueue (LinkQueue &Q) {// 构造一个空队列QQ.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));if (!Q.front) exit (OVERFLOW);//存储分配失败Q.front->next = NULL;return OK;}Status EnQueue (LinkQueue &Q, QElemType e) { // 插入元素e为Q的新的队尾元素QueuePtr p = (QueuePtr) malloc (sizeof (QNode));if (!p) exit (OVERFLOW); //存储分配失败p->data = e;p->next = NULL;Q.rear->next = p;Q.rear = p;return OK;}Status DeQueue (LinkQueue &Q, QElemType &e) { // 若队列不空,则删除Q的队头元素,//用e 返回其值,并返回OK;否则返回ERROR if (Q.front == Q.rear) return ERROR;QueuePtr p = Q.front->next;e = p->data;Q.front->next = p->next;if (Q.rear == p) Q.rear = Q.front;free (p);return OK;}//判断队列是否为空bool QueueEmpty(LinkQueue &Q){if(Q.front == Q.rear)return true;elsereturn false;}/*main.cpp 文件*/#include <stdio.h>#include <stdlib.h>#include "linkQueueOp.h"void main(){printf("Hello LinkQueue \n");LinkQueue Q; //定义顺序队列QQElemType e;if(OK != InitQueue(Q)) {printf("顺序队列初始化出错,退出....\n");exit(-1);}EnQueue(Q,1);EnQueue(Q,3);EnQueue(Q,5);EnQueue(Q,7);DeQueue(Q,e);printf("队首元素%d出队,\n",e);EnQueue(Q,9);EnQueue(Q,11);while(!QueueEmpty(Q)){DeQueue(Q,e);printf("队首元素%d出队,\n",e);}getchar();}。

栈队列查找表题目

栈队列查找表题目

题库-栈和队列,查找表;第一部分栈和队列一、填空题1、在栈结构中,允许插入、删除的一端称为__ ____,另一端称为_ _____。

2、对于顺序存储的栈,因为栈的空间是有限的,在进行运算时,可能发生栈的上溢。

3、用单链表实现一个栈的时候,插入一个元素时在单链表的进行。

4、链式栈永远不会发生栈满的情况,此说法是。

5、设有一个顺序栈S,元素1, 2, 3, 4, 5, 6依次进栈,如果6个元素的出栈顺序为2, 3, 4, 6, 5, 1,则顺序栈的容量至少应为。

6、两个栈共享一个向量空间时两个栈的栈底在。

7、向栈中压入元素x的操作是____________。

8、对栈进行退栈时的操作是____________。

9、顺序存储的栈在进行运算时,可能发生栈的下溢。

10、一个栈的输入序列是12345,则栈的输出序列是43521是___ __________。

13、递归算法中,每次递归调用前,系统自动将需要保持的数据放入中。

14、设有一个空栈,现有输入序列1,2,3,4,5,经过push,push,pop,push,pop,push,push 后,输出序列是。

15、在队列中存取数据应遵从的原则是_ ______。

(1)在循环队列中,队空的条件为________;队满的条件为__ ______。

(2)当rear>=front时,队列长度为_____________________;二、选择题1、在栈中存取数据的原则是()。

A.先进先出B.后进先出C.后进后出D.随意进出2、若已知一个栈的入栈序列是1,2,3,……,n,其输出序列是p1,p2,p3……,pn,若p1=n,则pi为( )。

A.I B.n-I C.n-I+1 D.不确定3、判断一个栈ST(最多元素m0)为满的条件是()。

A.ST->top !=0 B. ST->top= =0C.ST->top!=m0 D. ST->top = =m0-14、由两个栈共享一个向量空间的好处是:()。

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

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

栈的应用:进制转换实验原理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。

《数据结构》实验书

《数据结构》实验书

目录实验一线性表基本操作的编程实现 (201)实验二堆栈或队列基本操作的编程实现 (49)实验四二维数组基本操作的编程实现 (18)实验五二叉树基操作的编程实现 (20)实验六图基本操作的编程实现 (45)(特别提示:程序设计包含两个方面的错误。

其一是错误,其二是能错误。

为了提高学生的编程和能力,本指导书给出的程序代码并的两种错误。

并且也不保证程序的完整性,有一些语句已经故意删除,就是要求学生自己编制完成,这样才能达到我们的要求。

希望大家以自己所学高级语言的基本功和点为基础,不要过于依赖给出的参考代码,这样才能有所进步。

如果学生能够根据要求完全自己编制,那就不好了。

)实验一线性表基本操作的编程实现【实验目的】线性表基本操作的编程实现要求:线性表基本操作的编程实现(2学时,验证型),掌握线性表的建立、遍历、插入、删除等基本操作的编程实现,也可以进一步编程实现查找、逆序、排序等操作,存储结构可以在顺序结构或链表结分主要功能,也可以用菜单进行管理完成大部分功能。

还鼓励学生利用基本操作进行一些更实际的应用型程序设计。

【实验性质】【实验内容】把线性表的顺序存储和链表存储的数据插入、删除运算其中某项进行程序实现。

建议实现键盘输入数据以实现程序的通据的函数。

【注意事项】【思考问题】1.线性表的顺序存储和链表存储的差异?优缺点分析?2.那些操作引发了数据的移动?3.算法的时间效率是如何体现的?4.链表的指针是如何后移的?如何加强程序的健壮性?【参考代码】(一)利用顺序表完成一个班级学生课程成绩的简单管理1、预定义以及顺序表结构类型的定义(1)#define ListSize //根据需要自己设定一个班级能够容纳的最大学生数(2)typedef struct Stu{int num; //学生的学号char name[10]; //学生的姓名float wuli; //物理成绩float shuxue; //数学成绩float yingyu; //英语成绩}STUDENT; //存放单个学生信息的结构体类型typedef struct List{stu[ListSize]; //存放学生的数组定义,静态分配空间int length; //记录班级实际学生个数}LIST; //存放班级学生信息的顺序表类型2、建立班级的学生信息void listcreate(LIST *Li,int m) //m为该班级的实际人数{int i;Li->length=0;for(i=0;i<m;i++) //输入m个学生的所有信息{printf("please input the %dth student's information:\n",i+1);printf("num=");scanf("%d", ); //输入第i个学生的学号printf("name=");scanf("%s", ); //输入第i个学生的姓名printf("wuli=");scanf("%f", ); //输入第i个学生的物理成绩printf("shuxue=");scanf("%f", ); //输入第i个学生的数学成绩printf("yingyu=");scanf("%f", ); //输入第i个学生的英语成绩Li->length++; //学生人数加1}}3、插入一个学生信息int listinsert(LIST *Li,int i) //将学生插入到班级Li的第i个位置。

c++递归进制转换

c++递归进制转换

c++递归进制转换递归是一种常见的编程技术,可以在解决问题时更加简洁和优雅。

在进制转换中,递归可以很好地帮助我们实现十进制到二进制、八进制、十六进制等进制的转换。

进制是一种用来表示数字的方法,它确定了数字中每一位的权值和所能表示的最大值。

常见的进制有10进制、2进制、8进制和16进制。

10进制是我们日常生活中最常用的进制,它由0-9这10个数字表示。

而2进制则只有0和1,8进制有0-7,16进制有0-9和A-F。

我们以将十进制转换为二进制为例来详细讲解递归进制转换算法。

假设我们有一个十进制数num,现在要将其转换为二进制。

我们可以采用迭代的方式一位一位地将数字进行转换,但是使用递归可以使代码更简洁和可读。

递归算法的实现思路如下:1.首先,我们需要确定递归的结束条件。

对于二进制转换,当num 等于0时,转换完成,递归结束。

2.接下来,我们需要每次取num的最后一位数字,并将其转换为二进制。

这可以通过num % 2来得到最后一位的二进制数字。

3.再然后,我们需要将num的除最后一位外的其他位再次进行二进制转换,这可以通过num / 2来实现。

此时,我们可以递归调用转换函数本身,将num / 2作为参数传递给函数。

4.最后,我们将得到的二进制数字进行拼接,得到最终的二进制表示。

下面是用C++实现二进制转换的递归函数代码:```cpp#include <iostream>#include <string>std::string decimalToBinary(int num) {//递归结束条件if (num == 0) {return "0";}//数字转换为二进制std::string binary = std::to_string(num % 2);//递归调用return decimalToBinary(num / 2) + binary;}int main() {int num = 10;std::string binary = decimalToBinary(num);std::cout << "Decimal " << num << " is equal to Binary " << binary << std::endl;return 0;}```上述代码的逻辑非常清晰。

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

# include<stdio.h>
# define Stack_Size 50
typedef char StackElemType;
typedef struct
{
StackElemType elem[Stack_Size];
int top;
}SeqStack;
//初始化,设置一个空栈(清空栈)
void InitStack(SeqStack *s)
{
s->top=-1;
}
//插入(入栈)
int Push(SeqStack *s,StackElemType x)
{
if(s->top==Stack_Size-1)
{
printf("栈满,无法插入");
return 0;
}
s->top++;
//插入
s->elem[s->top]=x;
//插入成功,返回1
return 1;
}
//删除栈顶元素(出栈)
int Pop(SeqStack *s,StackElemType *x)
{
//栈空的时候,删除成功
if(s->top==-1)
{
printf("栈空,无法删除!");
return 0;
}
//带回将要被删除的元素
*x=s->elem[s->top];
//删除
s->top--;
return 1;
}
//取栈顶元素
int GetStackTop(SeqStack s,StackElemType *x)
{
//当栈为空时,取元素失败
if(s.top==-1) return 0;
//取元素
*x=s.elem[s.top];
return 1;
}
//输出栈的元素:
void OutPutStack(SeqStack s)
{
int i;
//从栈顶元素到栈底元素依次输出
i=s.top;
while(i>=0)
{
printf("%c",s.elem[i]);
i--;
printf("\n");
}
}
//栈空判断
int EmptyStack(SeqStack s)
{
if(s.top==-1)
return 1;
else 0;
}
void Transform1(int m)
{
SeqStack s;
InitStack(&s);
int r;
StackElemType x;
while(m!=0)
{
r=m%2;
Push(&s,r);
m=m/2;
}
while(s.top!=-1)
{
Pop(&s,&x);
printf("%d",x);
printf("\n");
}
void Transform2(int m) {
SeqStack s;
InitStack(&s);
int r;
StackElemType x;
while(m!=0)
{
r=m%8;
Push(&s,r);
m=m/8;
}
while(s.top!=-1)
{
Pop(&s,&x);
printf("%d",x);
}
printf("\n");
}
void Transform3(int m) {
SeqStack s;
InitStack(&s);
char r;
StackElemType x;
while(m!=0)
{
r=m%16;
if(r>=0&&r<=9)
r=r+'0';
else
r=r+'A'-10;
Push(&s,r);
m=m/16;
}
while(s.top!=-1)
{
Pop(&s,&x);
printf("%c",x);
printf("\n");
}
void main()
{
int m;
printf("请输入一个十进制整数:");
scanf("%d",&m);
printf("%d的二进制数是:",m);
Transform1(m);
printf("%d的八进制数是:",m);
Transform2(m);
printf("%d的十六进制数是:",m);
Transform3(m);
}。

相关文档
最新文档