您的位置：360文档中心› C语言 用栈实现进制转换

C语言 用栈实现进制转换

合集下载

(C语言)10进制转换2,8,16进制

(C语言)10进制转换2,8,16进制

（C语言）10进制转换2，8，16进制作者：vinseven#include"stdio.h"#include"conio.h"#include"malloc.h"#include"windows.h"#define ElemType intvoid menu();void TenToTwo();void TenToEight();void TenToSixteen();void InitStack(struct sNode **HS);void Push(struct sNode **HS,ElemType x);ElemType Pop(struct sNode **HS);ElemType Peek(struct sNode **HS);int EmptyStack(struct sNode **HS);void ClearStack(struct sNode **HS);int ten;/*要输入的10进制数*/int x;/*把将要插入到栈中的元素暂时存进 x 中*/struct sNode hs;struct sNode{ElemType data;struct sNode *next;};void main(){menu();getch();}void menu(){char choice;int flag=1;while(1){printf("\n\t\t\t________________________\n\n\n");printf("\t\t\t 1，10进制转换2进制\n\n\n");printf("\t\t\t 2，10进制转换8进制\n\n\n");printf("\t\t\t 3，10进制转换16进制\n\n\n");printf("\t\t\t 0，退出\n\n\n");printf("\t\t\t________________________\n\n");printf("\t\t\t请输入编号：");while(flag){fflush(stdin);choice=getch();switch(choice){case '1':{system("cls");TenToTwo();flag=0;break;}case '2':{system("cls");TenToEight();flag=0;break;}case '3':{system("cls");TenToSixteen();flag=0;break;}case '0':{printf("\n\t\t\t按任意键退出");getch();exit(0);}default:{printf("\n\t\t\t无此选项可选！请重新输入！\n");flag=1;break;}}}system("cls");flag=1;}}/*10进制转换2进制界面*/void TenToTwo(){printf("\n\t\t\t________________________\n\n\n");printf("\t\t\t 10进制转换2进制界面\n\n\n");printf("\t\t\t________________________\n\n");printf("\t\t\t请输入10进制数：");scanf("%d",&ten);while(ten!=0){x=ten%2;Push(&hs,x);ten=ten/2;}printf("\t\t\t二进制数为：");while(!EmptyStack(&hs))printf("%d",Pop(&hs));getch();}/*10进制转换8进制界面*/void TenToEight(){printf("\n\t\t\t________________________\n\n\n");printf("\t\t\t 10进制转换8进制界面\n\n\n");printf("\t\t\t________________________\n\n");printf("\t\t\t请输入10进制数：");scanf("%d",&ten);while(ten!=0){x=ten%8;Push(&hs,x);ten=ten/8;}printf("\t\t\t八进制数为：");while(!EmptyStack(&hs))printf("%d",Pop(&hs));getch();}/*10进制转换16进制界面*/void TenToSixteen(){int temp;printf("\n\t\t\t________________________\n\n\n");printf("\t\t\t 10进制转换16进制界面\n\n\n");printf("\t\t\t________________________\n\n");printf("\t\t\t请输入10进制数：");scanf("%d",&ten);while(ten!=0){x=ten%16;Push(&hs,x);ten=ten/16;}printf("\t\t\t十六进制数为：");while(!EmptyStack(&hs)){temp=Pop(&hs);switch(temp){case 1:case 2:case 3:case 4:case 5:case 6:case 7:case 8:case 9:printf("%d",temp);break;case 10:printf("A");break;case 11:printf("B");break;case 12:printf("C");break;case 13:printf("D");break;case 14:printf("E");break;case 15:printf("F");break;}}getch();}/*关于栈的函数*//*1，初始化链栈为空*/void InitStack(struct sNode **HS) {*HS=NULL;}/*2，向栈中插入一个元素*/void Push(struct sNode **HS,ElemType x){struct sNode *newp;newp=malloc(sizeof(struct sNode));if(newp==NULL){printf("内存动态空间用完，退出运行！");system("pause");exit(0);}newp->data=x;newp->next=*HS;*HS=newp;}/*3，从栈中删除一个函元素并返回它*/ ElemType Pop(struct sNode **HS){struct sNode *p;ElemType temp;if(*HS==NULL){printf("栈空！无法删除！");system("pause");exit(0);}p=*HS;*HS=p->next;temp=p->data;free(p);return temp;}/*4，读取栈顶元素*/ElemType Peek(struct sNode **HS){if(*HS==NULL){printf("栈空！无法读取栈顶结点！");system("pause");exit(1);}return (*HS)->data;}/*5，检查链栈是否为空,空返回1，否则返回0*/ int EmptyStack(struct sNode **HS){if(*HS==NULL)return 1;elsereturn 0;}/*6，清除链栈为空*/void ClearStack(struct sNode **HS){struct sNode *cp,*np;cp=*HS;while(cp!=NULL){np=cp->next;free(cp);cp=np;}*HS=NULL; }。

c语言进制转换算法

c语言进制转换算法

c语言进制转换算法在C语言中，可以使用以下算法进行进制转换：1. 将十进制数转换为任意进制数```c#include <stdio.h>void decimalToBase(int n, int base) {char result[32] = {'\0'}; // 用于存储结果的字符数组int i = 0;while (n > 0) {int remainder = n % base;result[i++] = remainder < 10 ? remainder + '0' : remainder - 10 + 'A'; // 将余数转换为对应的字符存储到结果数组中n = n / base;}for (int j = i - 1; j >= 0; j--) {printf("%c", result[j]); // 从后往前输出结果数组中的字符}}int main() {int n = 102; // 十进制数int base = 16; // 目标进制数printf("Base %d: %s\n", base, decimalToBase(n, base)); // 调用函数进行转换并输出结果return 0;}```这个算法的基本思路是不断地将原数除以目标进制的基数，将余数转换为对应的字符存储到结果数组中，直到原数为0为止。

最后从后往前输出结果数组中的字符即可得到转换后的结果。

2. 将任意进制数转换为十进制数这个算法可以使用类似于上面的算法的逆过程实现，即不断地将原数乘以目标进制的基数，取出整数部分作为新的余数，直到原数为0为止。

最后将所有的余数按照从低位到高位的顺序相加即可得到转换后的十进制数。

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

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

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

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

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

数据结构c语言版第三版习题解答

数据结构c语言版第三版习题解答

数据结构c语言版第三版习题解答数据结构 C 语言版第三版习题解答在学习计算机科学与技术的过程中，数据结构是一门非常重要的基础课程。

而《数据结构C 语言版第三版》更是众多教材中的经典之作。

其中的习题对于我们理解和掌握数据结构的概念、原理以及算法实现起着至关重要的作用。

接下来，我将为大家详细解答这本书中的一些典型习题。

首先，让我们来看一道关于线性表的习题。

题目是这样的：设计一个算法，从一个有序的线性表中删除所有其值重复的元素，使表中所有元素的值均不同。

对于这道题，我们可以采用双指针的方法来解决。

定义两个指针 p和 q，p 指向线性表的开头，q 从 p 的下一个位置开始。

当 q 所指向的元素与 p 所指向的元素相同时，我们就将 q 所指向的元素删除，并将 q 向后移动一位。

当 q 所指向的元素与 p 所指向的元素不同时，我们将 p 向后移动一位，并将 q 所指向的元素赋值给 p 所指向的位置，然后再将 q 向后移动一位。

当 q 超出线性表的范围时，算法结束。

下面是用 C 语言实现的代码：｀｀｀cvoid removeDuplicates(int arr, int n) ｛int p ＝ 0, q ＝ 1;while （q ＜ n) ｛if （arrp ＝＝ arrq) ｛for （int i ＝ q; i ＜ n 1; i+＋）｛arri ＝ arri ＋ 1;｝（n)；｝ else ｛p+＋；arrp ＝ arrq;｝q+＋；｝｝｀｀｀再来看一道关于栈的习题。

题目是：利用栈实现将一个十进制数转换为八进制数。

我们知道，将十进制数转换为八进制数可以通过不断除以 8 取余数的方法来实现。

而栈的特点是后进先出，正好适合存储这些余数。

以下是 C 语言实现的代码：｀｀｀cinclude ＜stdioh>include ＜stdlibh>define MAX_SIZE 100typedef struct ｛int top;int dataMAX_SIZE;｝ Stack;／／初始化栈void initStack(Stack s) ｛s>top ＝－1;｝／／判断栈是否为空int isEmpty(Stack s) ｛return s>top ＝＝－1;｝／／判断栈是否已满int isFull(Stack s) ｛return s>top ＝＝ MAX_SIZE 1;｝／／入栈操作void push(Stack s, int element) ｛if （isFull(s)）｛printf(＂Stack Overflow!＼n"）；return;｝s>data+＋s>top ＝ element;｝／／出栈操作int pop(Stack s) ｛if （isEmpty(s)）｛printf(＂Stack Underflow!＼n"）；return －1;｝return s>datas>top;｝／／将十进制转换为八进制void decimalToOctal(int decimal) ｛Stack s;initStack(＆s)；while （decimal!＝ 0) ｛push(＆s, decimal ％ 8)；decimal ／＝ 8;｝while （！isEmpty(＆s)）｛printf(＂％d"， pop(＆s)）；｝printf(＂＼n"）；｝int main(）｛int decimal;printf(＂请输入一个十进制数: ＂）；scanf(＂％d"，＆decimal)；printf(＂转换后的八进制数为: ＂）；decimalToOctal(decimal)；return 0;｝｀｀｀接下来是一道关于队列的习题。

c语言基于栈的进制转换

c语言基于栈的进制转换

c语言基于栈的进制转换栈是一种非常重要的数据结构，在计算机科学中应用广泛。

而基于栈的进制转换是我们在学习计算机编程过程中经常遇到的问题之一。

本文将介绍什么是栈、栈的特性以及如何利用栈实现进制转换。

首先，我们先来了解一下栈的概念。

栈是一种后进先出（LIFO）的数据结构，可以类比成一摞盘子，每次我们在放新盘子时都会把它放在现有的盘子顶部，而取出盘子时也是从顶部开始取。

栈有两个基本操作：压栈（push）和出栈（pop）。

压栈表示往栈中添加一个元素，出栈表示从栈中取出一个元素。

栈的特性使其对于进制转换非常适用。

我们知道，计算机中常用的进制有十进制、二进制、八进制和十六进制。

这些进制之间的转换可以借助栈来实现。

以十进制转二进制为例，我们可以使用栈来进行转换。

具体步骤如下：1. 将十进制数不断除以2，直到商为0为止。

2. 将每次的余数压入栈中。

3. 依次出栈，得到的就是转换后的二进制数。

这是因为，栈的后进先出特性使得每个余数都按照相反的顺序出栈，最后得到的二进制数也是正确的。

类似地，我们也可以用栈来实现其他进制之间的转换。

只需要将除以对应进制，将余数压入栈，然后依次出栈即可。

除了进制转换，栈还可以应用于其他方面。

比如，括号匹配问题就可以使用栈来解决。

通过遍历字符串，当遇到左括号时，将其压入栈中；当遇到右括号时，检查栈顶元素是否为与之匹配的左括号。

如果匹配成功，则将栈顶元素出栈；如果匹配失败，则表示括号不匹配，整个表达式无效。

总之，栈是一种非常有用的数据结构，可以应用于进制转换、括号匹配等多种场景。

对于初学者来说，理解栈的特性和使用方法对于掌握编程技巧非常重要。

通过解决实际问题，加深对栈的理解，相信能够在编程中得心应手。

C语言用栈实现十进制转换为二进制的方法示例

C语言用栈实现十进制转换为二进制的方法示例

C语⾔⽤栈实现⼗进制转换为⼆进制的⽅法⽰例本⽂实例讲述了C语⾔⽤栈实现⼗进制转换为⼆进制的⽅法。

分享给⼤家供⼤家参考，具体如下：#include<stdio.h>#include<malloc.h>#include<math.h>#include<string.h>#include "process.h"#define SIZE 100#define STACKINCREMENT 10#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedef int Status;typedef struct{int a;} SElemType;typedef struct{SElemType *base;SElemType *top;int stacksize;} SqStack;SqStack S; //定义全局变量Status InitStack(SqStack *S){S->base=(SElemType *)malloc(SIZE*sizeof(SElemType));if(!S->base) exit(OVERFLOW);S->top=S->base;S->stacksize=SIZE;return OK;}Status Push(SqStack *S,SElemType e){if(S->top-S->base>=S->stacksize){S->base=(SElemType *)malloc((S->stacksize+STACKINCREMENT)*sizeof(SElemType));if(!S->base) exit(OVERFLOW);S->top=S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}*S->top++=e;//printf("%dwww\n",*--S->top);return OK;}Status Stackempty(SqStack *S){if(S->top==S->base)return TRUE;elsereturn FALSE;}Status Pop(SqStack *S,SElemType *e){if(S->top==S->base) return ERROR;*e=*--S->top;return OK;}Status DtoBTrans(int N,SqStack *S){SElemType e;while(N){e.a=N%2;Push(S,e);N=N/2;}while(!Stackempty(S)){Pop(S,&e);printf("%d",e);}return OK;}void main(){int x;InitStack(&S);printf("请输⼊⼗进制数：");scanf("%d",&x);DtoBTrans(x,&S);}运⾏结果：希望本⽂所述对⼤家C语⾔程序设计有所帮助。

C语言 链栈 实现十进制转换二进制,八进制,十六进制

C语言 链栈 实现十进制转换二进制,八进制,十六进制

最后运行结果：代码：#include <stdio.h>#include <stdlib.h>typedef struct Node{int data;struct Node *next;}StackNode;StackNode *top = NULL;void Push(int e){StackNode *p;p = (StackNode *)malloc(sizeof(StackNode));p->data = e;p->next = top;top = p;}bool IsEmpty(){return top == NULL ? true : false;}int Pop(){StackNode *p;int e;if (IsEmpty()){printf("The stack is empty, failed to pop!\n");return NULL;}p = top;e = p->data;top = top->next;free(p);return e;}void Print(){StackNode *p;p = top;if (IsEmpty()){printf("The stack is empty!\n");return;}printf("转换后的结果是：");while (p){if (p->data<10)printf("%d ", p->data);else{if (p->data == 10)printf("a");else if (p->data == 11)printf("b");else if (p->data == 12)printf("c");else if (p->data == 13)printf("d");else if (p->data == 14)printf("e");else if (p->data == 15)printf("f");else printf("data is wrong!");}p = p->next;}printf("\n");}void main(){int m, c, d, n;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(c);}Print();}。

C++数据结构用栈将十进制数转化为八进制数

C++数据结构用栈将十进制数转化为八进制数
}SqStack;
int InitStack(SqStack &S) //申请栈空间
{
S.base=new int[100];
if(!S.base) cout<<"OVERFLOW";
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return 1;
}
/*int GetTop(SqStack S,int &e)
cout<<endl;
system("pause");
return 0;
}
{
if(S.top==S.base)
return 0;
e=*(S.top-1);
return 1;
}*/
int Push(SqStack &S,int e) //把元素压入栈
{
if(S.top-S.base>=S.stacksize)
{
S.base=new int[110];
if(!S.base) cout<<"OVERFLOW";
S.top=S.base+S.stacksize;
}
*S.top++=e;
return 1;
}
int Pop(SqStack &S,int &e) //获取栈顶元素
{
if(S.top==S.base)
return 0;
e=*--S.top;
return 1;
}
void conversion(SqStack &S) //数制转换
{
InitStack(S);

用C语言解决数制转换问题

用C语言解决数制转换问题

用C语言解决数制转换问题摘要数据结构是计算机存储、组织数据的方式。

数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。

一般认为，一个数据结构是由数据元素依据某种逻辑联系组织起来的。

对数据元素间逻辑关系的描述称为数据的逻辑结构；数据必须在计算机内存储，数据的存储结构是数据结构的实现形式，是其在计算机内的表示；此外讨论一个数据结构必须同时讨论在该类数据上执行的运算才有意义。

在许多类型的程序的设计中，数据结构的选择是一个基本的设计考虑因素。

许多大型系统的构造经验表明，系统实现的困难程度和系统构造的质量都严重的依赖于是否选择了最优的数据结构。

许多时候，确定了数据结构后，算法就容易得到了。

有些时候事情也会反过来，我们根据特定算法来选择数据结构与之适应。

不论哪种情况，选择合适的数据结构都是非常重要的。

本课程设计主要使用不同的数据结构解决数制转换的问题。

在课程设计中，系统开发平台为Windows7，程序设计设计语言采用C语言，程序运行平台为Windows 98/2000/XP/7。

关键词程序设计；数制转换；C；课程设计；数据结构1 引言1. 课程设计目的高速发展的现代社会，计算机浩浩荡荡地成为了人们生活中不可缺少的一部分，帮助人们解决通信，联络，互动等各方面的问题。

计算机在处理数字是和人是不同的，计算机使用的是二进制，人们在日常生活中使用十进制，但是在一些特定场合使用其他进制的表示，所以需要进行不同进制之间的转换。

本课程设计主要解决不同的进制之间的转换问题，并且采用不同的数据结构进行存储和转换，实现普通的进制之间的转换。

在程序设计中，可以用使用很多种方法解决该问题。

例如：数组、栈、递归。

不同的方法实现转换的原理基本相同，只是代码的细节不同。

在我的程序中不同的方法所需的函数在一个单独的头文件里面，便以管理和修改。

2. 数据结构设计（1）数组的结构由于处理简单的情况，最大的数字将不大于整形的范围，在VS2008整形为4个字节，因此开辟的数组为33个元素。

利用栈实现数制转换（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。

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

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

实验报告（一）实验过程一、项目简介进制转换通过编写函数实现十进制浮点数到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;}实验总结通过对数据的单个读取并入栈，后续的出栈顺序为从上到下，先进后出，读取数据后为相反的顺序，而队列的顺序出队为先进先出，对小数的存储可直接进行读取。

C语言实现任意进制转换

C语言实现任意进制转换

C语言实现任意进制转换任意进制转换是指将一个数从一种进制表示转换为另一种进制表示。

在计算机科学中，常见的进制包括二进制、八进制、十进制和十六进制。

下面我们将以C语言为例，实现任意进制之间的转换。

一、十进制到其他进制的转换1.二进制转换对于一个十进制数，我们可以通过对其进行除2取余的操作，得到其二进制表示。

具体的实现如下：```c#include<stdio.h>void decimalToBinary(int num)int binary[32], i = 0;while (num > 0)binary[i] = num % 2;i++;num /= 2;}for (int j = i - 1; j >= 0; j--)printf("%d", binary[j]);}int mainint decimalNumber;printf("请输入一个十进制数：");scanf("%d", &decimalNumber);printf("转换为二进制数为：");decimalToBinary(decimalNumber);return 0;```2.八进制转换对于十进制数，可以通过对其进行除8取余的操作，得到其八进制表示。

具体的实现如下：```c#include<stdio.h>void decimalToOctal(int num)int octal[100], i = 0;while (num > 0)octal[i] = num % 8;i++;num /= 8;}for (int j = i - 1; j >= 0; j--)printf("%d", octal[j]);}int mainint decimalNumber;printf("请输入一个十进制数：");scanf("%d", &decimalNumber);printf("转换为八进制数为：");decimalToOctal(decimalNumber);return 0;```3.十六进制转换对于一个十进制数，可以通过对其进行除16取余的操作，得到其十六进制表示。

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

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

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

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

数制转换数据结构课程设计报告

数制转换数据结构课程设计报告

数制转换数据结构课程设计报告一、课程设计目的本次数制转换数据结构课程设计的主要目的是通过实际编程实现不同数制之间的转换，加深对数据结构和算法的理解和运用。

具体而言，包括熟练掌握栈和队列等数据结构，以及运用递归、循环等算法思想来解决实际问题。

二、需求分析数制转换是计算机科学中常见的操作，常见的数制包括二进制、八进制、十进制和十六进制。

用户需要输入一个数以及其对应的原始数制，然后选择要转换的目标数制，程序能够准确地进行转换并输出结果。

三、数据结构选择在本次课程设计中，选择使用栈来实现数制转换。

栈具有后进先出的特点，非常适合在数制转换中进行余数的存储和处理。

四、算法设计（一）十进制转换为其他进制1、十进制转换为二进制：采用除 2 取余的方法，将每次除法的余数压入栈中，最后依次出栈得到二进制数。

2、十进制转换为八进制：采用除 8 取余的方法，与二进制类似，将余数压入栈中，最后出栈得到八进制数。

3、十进制转换为十六进制：除 16 取余，不过余数可能是 0 9 以及A F ，需要进行特殊处理。

（二）其他进制转换为十进制1、二进制转换为十进制：从右往左依次用二进制位上的数字乘以2 的相应位数的幂，然后将结果相加。

2、八进制转换为十进制：从右往左依次用八进制位上的数字乘以8 的相应位数的幂，然后将结果相加。

3、十六进制转换为十进制：从右往左依次用十六进制位上的数字乘以 16 的相应位数的幂，然后将结果相加。

A F 分别表示 10 15 。

（三）其他进制之间的转换通过先将原始进制转换为十进制，再将十进制转换为目标进制来实现。

五、程序实现以下是使用 C 语言实现的部分核心代码：｀｀｀cinclude ＜stdioh>include ＜stdlibh>／／定义栈的数据结构typedef struct Stack ｛int data;int top;int capacity;｝ Stack;／／创建栈Stack createStack(int capacity) ｛Stack stack ＝（Stack ）malloc(sizeof(Stack)）；stack>data ＝（int ）malloc(capacity sizeof(int)）；stack>top ＝－1;stack>capacity ＝ capacity;return stack;｝／／入栈操作void push(Stack stack, int element) ｛if （stack>top ＝＝ stack>capacity 1) ｛printf(＂Stack Overflow!＼n"）；return;｝stack>data+＋stack>top ＝ element;｝／／出栈操作int pop(Stack stack) ｛if （stack>top ＝＝－1) ｛printf(＂Stack Underflow!＼n"）；return －1;｝return stack>datastack>top;｝／／十进制转二进制void decimalToBinary(int decimal) ｛Stack stack ＝ createStack(32)；while （decimal ＞ 0) ｛push(stack, decimal ％ 2)；decimal ／＝ 2;while （stack>top!＝－1) ｛printf(＂％d"， pop(stack)）；｝printf(＂＼n"）；free(stack>data)；free(stack)；｝／／十进制转八进制void decimalToOctal(int decimal) ｛Stack stack ＝ createStack(16)；while （decimal ＞ 0) ｛push(stack, decimal ％ 8)；decimal ／＝ 8;｝while （stack>top!＝－1) ｛printf(＂％d"， pop(stack)）；printf(＂＼n"）；free(stack>data)；free(stack)；｝／／十进制转十六进制void decimalToHexadecimal(int decimal) ｛Stack stack ＝ createStack(16)；while （decimal ＞ 0) ｛int remainder ＝ decimal ％ 16;if （remainder ＜ 10) ｛push(stack, remainder ＋＇0'）；｝ else ｛push(stack, remainder 10 ＋＇A'）；｝decimal ／＝ 16;｝while （stack>top!＝－1) ｛printf(＂％c"， pop(stack)）；｝printf(＂＼n"）；free(stack>data)；free(stack)；｝／／二进制转十进制int binaryToDecimal(char binary) ｛int decimal ＝ 0, power ＝ 1;int length ＝ strlen(binary)；for （int i ＝ length 1; i ＞＝ 0; i) ｛if （binaryi ＝＝＇1'）｛decimal ＋＝ power;｝power ＝ 2;｝return decimal;｝／／八进制转十进制int octalToDecimal(char octal) ｛int decimal ＝ 0, power ＝ 1;int length ＝ strlen(octal)；for （int i ＝ length 1; i ＞＝ 0; i) ｛decimal ＋＝（octali ＇0'） power;power ＝ 8;｝return decimal;｝／／十六进制转十进制int hexadecimalToDecimal(char hexadecimal) ｛int decimal ＝ 0, power ＝ 1;int length ＝ strlen(hexadecimal)；for （int i ＝ length 1; i ＞＝ 0; i) ｛if （hexadecimali ＞＝＇0' ＆＆ hexadecimali ＜＝＇9'）｛decimal ＋＝（hexadecimali ＇0'） power;｝ else if （hexadecimali ＞＝＇A' ＆＆ hexadecimali ＜＝＇F'）｛decimal ＋＝（hexadecimali ＇A' ＋ 10) power;｝power ＝ 16;｝return decimal;｝int main(）｛int choice, decimal;char sourceNumber32;printf(＂1、 Decimal to Binary\n"）；printf(＂2、 Decimal to Octal\n"）；printf(＂3、 Decimal to Hexadecimal\n"）；printf(＂4、 Binary to Decimal\n"）；printf(＂5、 Octal to Decimal\n"）；printf(＂6、 Hexadecimal to Decimal\n"）；printf(＂Enter your choice: ＂）；scanf(＂％d"，＆choice)；switch （choice) ｛case 1:printf(＂Enter decimal number: ＂）；scanf(＂％d"，＆decimal)；decimalToBinary(decimal)；break;case 2:printf(＂Enter decimal number: ＂）；scanf(＂％d"，＆decimal)；decimalToOctal(decimal)；break;case 3:printf(＂Enter decimal number: ＂）；scanf(＂％d"，＆decimal)；decimalToHexadecimal(decimal)；break;case 4:printf(＂Enter binary number: ＂）；scanf(＂％s"， sourceNumber)；printf(＂％d\n"， binaryToDecimal(sourceNumber)）；break;case 5:printf(＂Enter octal number: ＂）；scanf(＂％s"， sourceNumber)；printf(＂％d\n"， octalToDecimal(sourceNumber)）；break;case 6:printf(＂Enter hexadecimal number: ＂）；scanf(＂％s"， sourceNumber)；printf(＂％d\n"， hexadecimalToDecimal(sourceNumber)）；break;default:printf(＂Invalid choice!＼n"）；｝return 0;｝｀｀｀六、测试与结果分析（一）测试用例1、十进制 10 转换为二进制、八进制、十六进制。

C语言的进制转换及算法实现教程

C语言的进制转换及算法实现教程

C语⾔的进制转换及算法实现教程1、其他进制转⼗进制1.1、⼆进制转⼗进制转换规程：从最低位开始，将每个位上的数提取出来，乘以2的(位数-1)次⽅，然后求和，例如：⼆进制 1011 = 1*2^0 + 1*2^1 + 0*2^2 + 1*2^3 = 1 + 2 + 0 + 8 = 111.2、⼋制转⼗进制转换规则：从最低位开始，将每个位上的数提取出来，乘以8的(位数-1)次⽅，然后求和，例如：⼋进制 0123 = 3*8^0 + 2*8^1 + 1*8^2 = 3+16+64 = 831.3、⼗六进制转⼗进制转换规则：从最低位开始，将每个位上的数提取出来，乘以16的(位数-1)次⽅，然后求和，例如：⼗六进制 0x34A = 10*16^0 + 4*16^1 + 3*16^2 = 10+64+768 = 8422、⼗进制转其他进制2.1、⼗进制转⼆进制binary规则：将该数不断除以2，直到商为0为⽌，然后将每步得到的余数倒过来，就是对应的⼆进制，故此法叫做除商逆序取余法；案例：将56转换为⼆进制56 ：56 / 2 = 28 余028 / 2 = 14 余014 / 2 = 7 余07 / 2 = 3 余13 / 2 = 1 余11 /2 = 0余 1故56转换为⼆进制的结果是：111000代码实现：#include <stdio.h>//转⼗进制⼆进制void main() {printf("请输⼊⼀个⼗进制数:");int binary = 0; //⼆进制数int b = 1; //循环标志int num[100] ; //⽤来存⼆进制的数组int index = 0; //数组的下标int count = -1; //⽤来计算数组的使⽤个数,这⾥使⽤-1是因为数组的下标是从0开始的//所以当我们循环⼀次去⾃增的时候，第⼀次应该是从0开始，如果count的初始值是0的话//就会导致使⽤的第⼀个数组的下标为1，那样会导致存数据的下标index和记录使⽤的下标count不⼀致//使数据溢出scanf("%d",&binary);while (b) {num[index] = binary % 2; //每次运算取余binary /= 2; //每次运算⼆进制数需要除以2//printf("num[%d]=%d\n",index,num[index]);index++; //每循环⼀次数组下标就移⼀位count++; //每循环⼀次就表⽰占⽤了数组的⼀个位置if (binary == 0) {b = 0;}}printf("占⽤数组位置%d个",count+1);printf("\n");printf("⼆进制数为：");for (int i = count; i >=0; i--) {printf("%d",num[i]);}getchar();getchar();//回车会被接收，所以需要两个来暂停控制台}2.2、⼗进制转⼋进制octonary规则：将该数不断除以8，直到商为0，然后将每步得到的余数倒过来，就是对应的⼋进制。

c语言二进制十进制十六进制转换计算

c语言二进制十进制十六进制转换计算

C语言是一种高级编程语言，它具有丰富的数学计算功能，其中包括二进制、十进制和十六进制之间的转换计算。

本文将重点介绍C语言中如何进行二进制、十进制和十六进制之间的转换计算，以及其相关的方法和注意事项。

一、二进制、十进制和十六进制的概念及表示方法1. 二进制二进制是一种基数为2的数制，它只包含0和1两个数字。

在C语言中，二进制数通常以0b或0B开头表示，例如0b1010表示十进制的10。

2. 十进制十进制是我们常用的数制，基数为10，包含了0到9这10个数字。

在C语言中，十进制数直接以数字形式表示，例如123表示十进制的123。

3. 十六进制十六进制是一种基数为16的数制，它包含0到9这10个数字以及A 到F这6个英文字母，分别对应10到15。

在C语言中，以0x或0X 开头表示十六进制数，例如0x1A表示十进制的26。

二、二进制与十进制的转换计算方法1. 二进制转十进制二进制转换为十进制可以使用加权法，即将二进制数从右向左依次乘以2的幂次方，然后将结果相加。

1010转换为十进制的计算过程为：1*2^3 + 0*2^2 + 1*2^1 + 0*2^0 = 10。

2. 十进制转二进制十进制转换为二进制可以使用除2取余法，即将十进制数不断除以2，将每次的余数倒序排列即可得到二进制数。

26转换为二进制的计算过程为：26÷2=13……0，13÷2=6……1，6÷2=3……0，3÷2=1……1，1÷2=0……1，倒序排列得到xxx。

三、十六进制与十进制的转换计算方法1. 十六进制转十进制十六进制转换为十进制可以使用加权法，即将十六进制数从右向左依次乘以16的幂次方，然后将结果相加。

1A转换为十进制的计算过程为：1*16^1 + A*16^0 = 26。

2. 十进制转十六进制十进制转换为十六进制可以使用除16取余法，即将十进制数不断除以16，将每次的余数倒序排列，A对应10，B对应11，依次类推，直到商为0即可得到十六进制数。

数据结构与算法--栈的应用（进制转换、括号匹配）

数据结构与算法--栈的应用（进制转换、括号匹配）

数据结构与算法--栈的应⽤（进制转换、括号匹配）栈的应⽤ps：⽤栈很简单实现的应⽤有很多，⽐如说进制转换，括号匹配等。

学计算机的都知道，2进制，8进制，10进制，16进制等，进制之间的转换也是需要掌握的，以备不时之需，所以我们可以⾃⼰写⼀段程序如果会android的话，可以直接打包成APK。

下⾯就按照这两个应⽤稍微写⼀点C语⾔的代码。

进制转换括号匹配1：进制转换 想要⾃⼰做⼀个进制转换的⼯具，⾸先我们要知道如何实现进制之间的转换，我们平常⽤的都是10进制，如果想要转成8进制怎么办，按照⽅法，如图可以看到，N是我们输⼊的10进制数，除以8，余数保留在栈中，得到的168接着与8整除运算，直到N div 8 等于0，最后把栈中数据取出即可，正好⽤到了栈的规则，先进后出的特性。

1.1：定义栈结构体typedef struct zhan{int data;struct zhan *next;}zhan,*ZhanL;1.2：初始化栈/*** 初始化栈* */ZhanL initZhan(){ZhanL L =(ZhanL)malloc(sizeof(zhan));L->next=NULL;return L;}1.3进栈出栈操作在pop⽅法中，把L赋给s，主要是出栈后，把空余的栈位释放掉，push⽅法⽤到了尾插法。

/*** 进栈操作* */int push(ZhanL &L,int data){//创建⼀个新的结点ZhanL p=(ZhanL)malloc(sizeof(zhan));p->data=data;p->next = L;L = p;return0;}int pop(ZhanL &L){if(L->next){ZhanL s=L;//释放空间⽤printf("%d ",s->data);L = L->next;if(L->next){// printf("栈顶%d \n",L->data);} else{printf("栈空\n");}free(s);}return0;}1.4：转换⽅法/*** 转换⽅法* */int zhuanhuan(ZhanL &L,int data,int jz){while (data){push(L,data%jz);data = data/jz;}while (L){pop(L);}return0;}1.5：使⽤int main(){ZhanL L;L=initZhan();printf("请输⼊⼀个⼗进制数");int data,jz;scanf("%d",&data);printf("请输⼊转换的进制");scanf("%d",&jz);zhuanhuan(L,data,jz);return0;}结果图：2：括号匹配什么是括号匹配？在编写代码的时候，经常会⽤到两种括号：圆括号 “()” 和⼤括号 “{}” 。

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

C语言用栈实现进制转换
#include<stdio.h>
#include<malloc.h>
#include<math.h>
#include<process.h>
#define S_SIZE 100 //栈所占空间的大小
#define STACKINCREAMENT 10 //扩充空间时一次扩充十个字节struct SqStack
{
int *base; //栈底
int *top; //栈顶
int stacksize;//栈当前的存储空间
}*S;
//主函数开始
void main()
{
//子函数声明
void InitStack(S);//初始化空栈
int StackEmpty(SqStack S);//判栈空
void GetTop(SqStack S,int &e);//获得栈顶元素
void push(SqStack &S,int e);//进栈
void pop(SqStack &S,int &e);//出栈
void convert(SqStack &5,int N,int n);//十进制转N进制
int i,num;
unsigned n,N;//要转换的进制数及要转换的数
SqStack s;
InitStack(s);//初始化空栈
printf("输入要转换的十进制数和要转换为的进制数:\n");
scanf("%d,%d",&N,&n);
printf("%d转换为%d进制后为：\n",N,n);
convert(s,N,n);
}
void InitStack(SqStack &S)
{
S.base = (int *)malloc(S_SIZE*sizeof(int));
S.stacksize=S_Size;
S.top=S.base;//初始化空栈
}
int StackEmpty(SqStack S)
{
if(S.base==S.top)
return 1;
else
return 0;
}
void GetTop(Stack S,int &e)
{
//获得栈顶元素
e = *(S.top-1);
}
void push(SqStack &5,int e)
{
//进栈
if(S.top - S.base >= S.stacksize)
{
S.base = (int *)realloc(S.base,(S.stacksize+STACKINCREAMENT)*sizeof(int));
S.top = S.base += S.stacksize;
S.stacksize += STACKINCREAMENT;
}
*(S.top)=e;
S.top++;
}
void pop(SqStack &S,int &e)
{
//出栈
if(S.base != S.top)
{
S.top--;
e=*S.top;
}
}
void convert(SqStack &S,int N,int n)
{
InitStack(S);
do
{
push(S,N&n);
N = N/n;
}while(N != 0);
int i,e;
while(!StackEmpty(S))
{
pop(S,e);
if(e > 9)//十六进制时输出字母
{
e = e + 55;
printf("%c",e);
}
else
printf("%d",e);
}
printf("\n");
}。

相关文档
最新文档