Chinaunix首页 | 论坛 | 博客

oops

首页　| 　博文目录　| 　关于我

王贤才

  • 博客访问： 1184720
  • 博文数量： 573
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 66
  • 用 户 组： 普通用户
  • 注册时间： 2016-06-28 16:21
文章分类

全部博文（573）

文章存档

2018年（3）

2016年（48）

2015年（522）

我的朋友
最近访客
推荐博文
相关博文
任意数制的转换

分类： C/C++

2015-12-02 14:53:54


点击(此处)折叠或打开

  1. #include <string.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <math.h>
  5. #include <assert.h>

  7. //编译：cc shuzhi_conversion.c -lm

  9. #define STACK_INIT_SIZE 10 /*栈空间的初始分配量*/
  10. #define STACKINCREAMENT 5 /*栈空间的分配增量*/

  12. typedef char eletype;

  14. /*定义顺序栈的结构体:描述了栈的所有要素*/
  15. typedef struct stack
  16. {
  17.     eletype * base; /*栈底指针*/
  18.     eletype * top; /*栈顶指针*/
  19.     int stacksize; /*记录栈的大小*/
  20. }STACK;
  21. typedef STACK * StackPtr;

  23. int InitStack(StackPtr stackptr);
  24. int StackIsEmpty(STACK stack);
  25. int Push(StackPtr stackptr, eletype ele);
  26. int Pop(StackPtr stackptr, eletype * ele);
  27. int GetTop(STACK stack, eletype * ele);
  28. int PrintStack(STACK stack);
  29. int StackLen(STACK stack);
  30. int DestroyStack(StackPtr stackptr);

  32. int conversion(int srcflag, char * src, int destflag, char * dest);
  33. int conversion_n_to_10(int srcflag, char * src, int destflag, char * dest);
  34. int conversion_10_to_n(int srcflag, char * src, int destflag, char * dest);

  36. int main(int argc, char ** argv)
  37. {
  38.     //freopen("shuzhi_conversion.txt", "w", stdout);
  39.     int srcflag;
  40.     int destflag;
  41.     char src[1024];
  42.     char dest[10242];
  43.     
  44.     printf("********************************************************************\n");
  45.     
  46.     srcflag = 10;
  47.     destflag = 16;
  48.     memset(src, 0, sizeof(src));
  49.     strcpy(src, "255");
  50.     memset(dest, 0 , sizeof(dest));
  51.     conversion(srcflag, src, destflag, dest);
  52.     printf("%d进制数=[%s], 转化为，%d进制数=[%s]\n", srcflag, src, destflag, dest);
  53.     
  54.     srcflag = 10;
  55.     destflag = 2;
  56.     memset(src, 0, sizeof(src));
  57.     strcpy(src, "34818");
  58.     memset(dest, 0 , sizeof(dest));
  59.     conversion(srcflag, src, destflag, dest);
  60.     printf("%d进制数=[%s], 转化为，%d进制数=[%s]\n", srcflag, src, destflag, dest);
  61.     
  62.     srcflag = 10;
  63.     destflag = 2;
  64.     memset(src, 0, sizeof(src));
  65.     strcpy(src, "2048");
  66.     memset(dest, 0 , sizeof(dest));
  67.     conversion(srcflag, src, destflag, dest);
  68.     printf("%d进制数=[%s], 转化为，%d进制数 =[%s]\n", srcflag, src, destflag, dest);
  69.     
  70.     srcflag = 10;
  71.     destflag = 2;
  72.     memset(src, 0, sizeof(src));
  73.     strcpy(src, "32770");
  74.     memset(dest, 0 , sizeof(dest));
  75.     conversion(srcflag, src, destflag, dest);
  76.     printf("%d进制数=[%s], 转化为，%d进制数=[%s]\n", srcflag, src, destflag, dest);
  77.     
  78.     printf("********************************************************************\n");
  79.     
  80.     srcflag = 16;
  81.     destflag = 10;
  82.     memset(src, 0, sizeof(src));
  83.     strcpy(src, "FF");
  84.     memset(dest, 0 , sizeof(dest));
  85.     conversion(srcflag, src, destflag, dest);
  86.     printf("%d进制数=[%s], 转化为，%d进制数=[%s]\n", srcflag, src, destflag, dest);
  87.     
  88.     srcflag = 9;
  89.     destflag = 10;
  90.     memset(src, 0, sizeof(src));
  91.     strcpy(src, "13");
  92.     memset(dest, 0 , sizeof(dest));
  93.     conversion(srcflag, src, destflag, dest);
  94.     printf("%d进制数=[%s], 转化为，%d进制数=[%s]\n", srcflag, src, destflag, dest);
  95.     
  96.     srcflag = 8;
  97.     destflag = 10;
  98.     memset(src, 0, sizeof(src));
  99.     strcpy(src, "12");
  100.     memset(dest, 0 , sizeof(dest));
  101.     conversion(srcflag, src, destflag, dest);
  102.     printf("%d进制数=[%s], 转化为，%d进制数=[%s]\n", srcflag, src, destflag, dest);
  103.     
  104.     srcflag = 2;
  105.     destflag = 10;
  106.     memset(src, 0, sizeof(src));
  107.     strcpy(src, "11111111111111111111111111111111");
  108.     memset(dest, 0 , sizeof(dest));
  109.     conversion(srcflag, src, destflag, dest);
  110.     printf("%d进制数=[%s], 转化为，%d进制数=[%s]\n", srcflag, src, destflag, dest);
  111.     
  112.     printf("********************************************************************\n");
  113.     
  114.     srcflag = 16;
  115.     destflag = 2;
  116.     memset(src, 0, sizeof(src));
  117.     strcpy(src, "FF");
  118.     memset(dest, 0 , sizeof(dest));
  119.     conversion(srcflag, src, destflag, dest);
  120.     printf("%d进制数=[%s], 转化为，%d进制数=[%s]\n", srcflag, src, destflag, dest);
  121.     
  122.     srcflag = 8;
  123.     destflag = 2;
  124.     memset(src, 0, sizeof(src));
  125.     strcpy(src, "766");
  126.     memset(dest, 0 , sizeof(dest));
  127.     conversion(srcflag, src, destflag, dest);
  128.     printf("%d进制数=[%s], 转化为，%d进制数=[%s]\n", srcflag, src, destflag, dest);
  129.     
  130.     srcflag = 2;
  131.     destflag = 16;
  132.     memset(src, 0, sizeof(src));
  133.     strcpy(src, "11111110");
  134.     memset(dest, 0 , sizeof(dest));
  135.     conversion(srcflag, src, destflag, dest);
  136.     printf("%d进制数=[%s], 转化为，%d进制数=[%s]\n", srcflag, src, destflag, dest);
  137.     
  138.     srcflag = 9;
  139.     destflag = 7;
  140.     memset(src, 0, sizeof(src));
  141.     strcpy(src, "12");
  142.     memset(dest, 0 , sizeof(dest));
  143.     conversion(srcflag, src, destflag, dest);
  144.     printf("%d进制数=[%s], 转化为，%d进制数=[%s]\n", srcflag, src, destflag, dest);
  145.     
  146.     printf("********************************************************************\n");

  148.     return 0;
  149. }

  151. /*功能：2,将其他任何进制的数，转化为10进制数*/
  152. int conversion_n_to_10(int srcflag, char * src, int destflag, char * dest)
  153. {
  154.     assert((srcflag != 10)&&(destflag == 10));
  155.     
  156.     STACK stack;
  157.     InitStack(&stack);
  158.     
  159.     char stach_push; /*存放入栈元素*/
  160.     char stach_pop; /*存放出栈元素*/
  161.     int i = -1;
  162.     
  163.     i = 0;
  164.     stach_push = *src;
  165.     while(stach_push != '\0')
  166.     {
  167.         Push(&stack, stach_push);
  168.         stach_push = *(src + ++i);
  169.     }
  170.     
  171.     i = 0;
  172.     int wei = -1;
  173.     double tempshu_10 = 0.00;
  174.     while(StackIsEmpty(stack) != 1)
  175.     {
  176.         Pop(&stack, &stach_pop);
  177.         switch(stach_pop)
  178.         {
  179.             case '0': wei = 0; break;
  180.             case '1': wei = 1; break;
  181.             case '2': wei = 2; break;    
  182.             case '3': wei = 3; break;
  183.             case '4': wei = 4; break;
  184.             case '5': wei = 5; break;
  185.             case '6': wei = 6; break;
  186.             case '7': wei = 7; break;
  187.             case '8': wei = 8; break;
  188.             case '9': wei = 9; break;
  189.             case 'A': wei = 10; break;
  190.             case 'B': wei = 11; break;
  191.             case 'C': wei = 12; break;
  192.             case 'D': wei = 13; break;
  193.             case 'E': wei = 14; break;
  194.             case 'F': wei = 15; break;
  195.         }
  196.         tempshu_10 += wei * pow(srcflag, i++);
  197.     }
  198.     sprintf(dest, "%.0f", tempshu_10);
  199.     
  200.     DestroyStack(&stack);
  201.     return 0;
  202. }

  204. /*功能：1,将10进制数，转化为其他任何进制的数*/
  205. int conversion_10_to_n(int srcflag, char * src, int destflag, char * dest)
  206. {
  207.     assert((srcflag == 10)&&(destflag != 10));
  208.     
  209.     STACK stack;
  210.     InitStack(&stack);
  211.     
  212.     char stach_push; /*存放入栈元素*/
  213.     char stach_pop; /*存放出栈元素*/
  214.     int i = -1;
  215.     
  216.     int shu_10 = -1;
  217.     shu_10 = atoi(src);
  218.     int yu = -1;
  219.     
  220.     while(shu_10 != 0)
  221.     {
  222.         yu = shu_10 % destflag;
  223.         switch(yu)
  224.         {
  225.             case 0: stach_push = '0'; break;
  226.             case 1: stach_push = '1'; break;
  227.             case 2: stach_push = '2'; break;    
  228.             case 3: stach_push = '3'; break;
  229.             case 4: stach_push = '4'; break;
  230.             case 5: stach_push = '5'; break;
  231.             case 6: stach_push = '6'; break;
  232.             case 7: stach_push = '7'; break;
  233.             case 8: stach_push = '8'; break;
  234.             case 9: stach_push = '9'; break;
  235.             case 10: stach_push = 'A'; break;
  236.             case 11: stach_push = 'B'; break;
  237.             case 12: stach_push = 'C'; break;
  238.             case 13: stach_push = 'D'; break;
  239.             case 14: stach_push = 'E'; break;
  240.             case 15: stach_push = 'F'; break;
  241.         }
  242.         Push(&stack, stach_push); /*把求余得到的余值入栈*/
  243.         shu_10 = shu_10 / destflag; /*得到的模值会继续求余*/
  244.     }
  245.     
  246.     i = 0;
  247.     while(StackIsEmpty(stack) != 1)
  248.     {
  249.         Pop(&stack, &stach_pop);
  250.         sprintf(dest + i++, "%c", stach_pop);
  251.     }    
  252.     
  253.     DestroyStack(&stack);
  254.     return 0;
  255. }

  257. /*功能：将[srcflag]进制数=字符串[src]，转化为[destflag]进制的数=字符串[dest]
  258. 目前
  259. 1,能将10进制数，转化为其他任何进制的数
  260. 2,能将其他任何进制的数，转化为10进制数
  261. */
  262. int conversion(int srcflag, char * src, int destflag, char * dest)
  263. {
  264.     if((srcflag != 10)&&(destflag != 10))
  265.     {
  266.         char temp[1024];
  267.         memset(temp, 0, sizeof(temp));
  268.         conversion_n_to_10(srcflag, src, 10, temp);
  269.         conversion_10_to_n(10, temp, destflag, dest);
  270.         return 0;
  271.     }
  272.     
  273.     if((srcflag != 10)&&(destflag == 10))
  274.     {
  275.         conversion_n_to_10(srcflag, src, destflag, dest);
  276.         return 0;
  277.     }
  278.     
  279.     if((srcflag == 10)&&(destflag != 10))
  280.     {
  281.         conversion_10_to_n(srcflag, src, destflag, dest);
  282.         return 0;
  283.     }    
  284. }

  286. /*功能：栈的初始化*/
  287. int InitStack(StackPtr stackptr)
  288. {
  289.     stackptr->base = (eletype *)malloc(STACK_INIT_SIZE * sizeof(eletype));
  290.     /*stack-> 等价于 (*stack).*/
  291.     /*栈底指针指向开辟的空间的地址低端,开辟的空间的地址类型是：eletype*/
  292.     if(stackptr->base == NULL)
  293.     {
  294.         printf("malloc失败，退出程序\n");
  295.         exit(-1);
  296.     }
  297.     stackptr->top = stackptr->base; /*栈顶指针也指向地址低端，表明是空栈*/
  298.     stackptr->stacksize = STACK_INIT_SIZE; /*记录栈的容量，不是栈中元素个数*/
  299.     
  300.     return 0;
  301. }

  303. /*功能：判断栈是否为空 1:空栈，2：非空栈*/
  304. int StackIsEmpty(STACK stack)
  305. {
  306.     //栈顶和栈底相同，即可判断为空
  307.     if(stack.top == stack.base)
  308.         return 1;
  309.     else
  310.         return 2;
  311. }

  313. /*功能：入栈操作*/
  314. int Push(StackPtr stackptr, eletype ele)
  315. {
  316.     /*要先判断栈是否已满*/
  317.     if((stackptr->top - stackptr->base) >= stackptr->stacksize)
  318.     {
  319.         /*top指针已经指向栈空间的最高地址的外面了。表示栈中元素已满：即“上溢”，则追加存储空间*/
  320.         stackptr->base = (eletype *)realloc(stackptr->base, (stackptr->stacksize + STACKINCREAMENT) * sizeof(eletype));
  321.         if(stackptr->base == NULL)
  322.         {
  323.             printf("realloc失败，退出程序\n");
  324.             exit(-1);
  325.         }
  326.         stackptr->top = stackptr->base + stackptr->stacksize; /*当前栈顶指针=栈底指针+栈的原来的容量*/
  327.         stackptr->stacksize = stackptr->stacksize + STACKINCREAMENT; /*栈的容量已经改变*/
  328.     }
  329.     *(stackptr->top) = ele; //元素e入栈
  330.     stackptr->top = (stackptr->top)++; //保证:栈顶指针始终在栈顶元素的下一个位置
  331.     
  332.     /*
  333.     *((*stackptr).top) = ele;
  334.     (*stackptr).top = (*stackptr).top + 1;
  335.     */
  336.     //printf("入栈一个元素=[%d],栈空间大小=[%d],栈中元素个数=[%d]\n", ele, stackptr->stacksize, StackLen(*stackptr));
  337.     return 0;
  338. }

  340. /*功能：出栈操作*/
  341. int Pop(StackPtr stackptr, eletype * ele)
  342. {
  343.     /*先判断是否是空栈*/
  344.     if(stackptr->top == stackptr->base)
  345.     {
  346.         printf("栈为空，无元素可出栈！\n");
  347.         return -1;
  348.     }
  349.     stackptr->top = stackptr->top -1;
  350.     *ele = *(stackptr->top);
  351.     //printf("出栈一个元素=[%d],栈空间大小=[%d],栈中元素个数=[%d]\n", *ele, stackptr->stacksize, StackLen(*stackptr));
  352.     return 0;
  353. }

  355. /*功能：取栈顶元素*/
  356. int GetTop(STACK stack, eletype * ele)
  357. {
  358.     /*先判断是否是空栈*/
  359.     if(stack.top == stack.base)
  360.     {
  361.         printf("栈为空，无栈顶元素可取！\n");
  362.         return -1;
  363.     }
  364.     stack.top = stack.top -1; /*只是取栈顶元素，不可移动栈顶指针*/
  365.     *ele = *(stack.top);
  366.     printf("当前栈顶元素=[%c]!\n", *ele);
  367.     return 0;
  368. }

  370. /*功能：打印栈中的所有元素*/
  371. int PrintStack(STACK stack)
  372. {
  373.     printf("栈空间大小=[%d],栈中元素个数=[%d]\n", stack.stacksize, StackLen(stack));
  374.     /*先判断是否是空栈*/
  375.     if(stack.top == stack.base)
  376.     {
  377.         printf("栈为空,无需打印栈中元素!\n");
  378.         return -1;
  379.     }
  380.     int num = 0;
  381.     stack.top = stack.top -1;
  382.     printf("从栈顶开始：");
  383.     while(stack.top != stack.base)
  384.     {
  385.         num++;
  386.         printf("(第%02d个元素)=[%c]->", num, *(stack.top));
  387.         (stack.top)--;
  388.     }
  389.     if(stack.top == stack.base) /*说明已经指向栈底了*/
  390.     {
  391.         num++;
  392.         printf("(第%02d个元素)=[%c]\n", num, *(stack.top));
  393.     }
  394.         
  395.     return 0;
  396. }

  398. /*功能：求栈中元素的个数*/
  399. int StackLen(STACK stack)
  400. {
  401.     int num = 0;
  402.     /*先判断是否是空栈*/
  403.     if(stack.top == stack.base)
  404.     {
  405.         /*printf("栈为空!\n");*/
  406.         num = 0;
  407.         return num;
  408.     }
  409.     stack.top = stack.top -1;
  410.     while(stack.top != stack.base)
  411.     {
  412.         num++;
  413.         (stack.top)--;
  414.     }
  415.     if(stack.top == stack.base) /*说明已经指向栈底了*/
  416.     {
  417.         num++;
  418.     }
  419.     
  420.     return num;
  421. }


  424. /*功能：销毁栈*/
  425. int DestroyStack(StackPtr stackptr)
  426. {
  427.     free(stackptr->base);
  428.     stackptr->base = NULL;
  429.     stackptr->top = NULL;
  430.     stackptr->stacksize = 0;
  431.     //printf("顺序栈已销毁！\n");
  432.     
  433.     return 0;
  434. }

阅读(677) | 评论(0) | 转发(0) |
0

上一篇：顺序栈

下一篇：单非循环链表

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6