关于二进制转八进制的代码

我叫淳子

我昨天晚上看了小甲鱼的用栈实现二进制转十进制，然后留给我们的作业是二进制转八进制和十六进制，昨天编了我好久，都没编成功，昨天睡觉前整理了一下思路，今天早上编成功的，这次是自己编的啊，就是栈的部分是参考小甲鱼视频里的，由于那堂课的源代码要30鱼币，好贵的，只好自己苦命的编了。求大神指导。

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #include<math.h>
   
4. 
   
5. #define STACK_INIT_SIZE 20
   
6. #define STACKICREAMENT  10
   
7. 
   
8. typedef char ElemType;
   
9. typedef struct
   
10. {
    
11.         ElemType *top;
    
12.         ElemType *base;
    
13.         int stacksize;
    
14. }sqStack;
    
15. 
    
16. void Initstack(sqStack *s)
    
17. {
    
18.         s->base=(ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType) );
    
19.         if(!s->base)
    
20.         {
    
21.                 exit(0);
    
22.         }
    
23.         s->top=s->base;
    
24.         s->stacksize=STACK_INIT_SIZE;
    
25. }
    
26. 
    
27. void Push(sqStack *s, ElemType e)
    
28. {
    
29.         if(s->top - s->base >= s->stacksize)
    
30.         {
    
31.                 s->base=realloc(s->base, (s->stacksize + STACKICREAMENT ) * sizeof(ElemType) );
    
32.                 if(!s->base)
    
33.                 {
    
34.                         exit(0);
    
35.                 }
    
36.         }
    
37.         *(s->top)=e;
    
38.         s->top++;
    
39. }
    
40. 
    
41. void Pop(sqStack *s, ElemType *e)
    
42. {
    
43.         if(s->top==s->base)
    
44.         {
    
45.                 return;
    
46.         }
    
47.         *e= *--(s->top);
    
48. }
    
49. 
    
50. int Stacksize(sqStack s)
    
51. {
    
52.         return (s.top - s.base);
    
53. }
    
54. int main()
    
55. {
    
56.         int i,j,k,a,len,len1,len2,sum1=0,sum2=0;
    
57.         ElemType e,sum;
    
58.         sqStack s1,s2;
    
59.         Initstack(&s1);
    
60.         Initstack(&s2);
    
61.         printf("请输入二进制数,以#结束\n");
    
62.         scanf("%c",&e);
    
63.         while(e!='#')
    
64.         {
    
65.                 Push(&s1,e);
    
66.                 scanf("%c",&e);
    
67.         }
    
68.        
    
69.         getchar();
    
70.        
    
71.         len1=Stacksize(s1);
    
72.         printf("该栈的容量为%d\n",len1);
    
73.         len=len1;
    
74.         while(len % 3 != 0)
    
75.         {
    
76.                 len++;
    
77.         }
    
78.         for(i=0; i< len /3; i++)
    
79.         {
    
80.        
    
81.             a=3;
    
82.             if(i == len /3 - 1 && len != len1)
    
83.             {
    
84.                     a= len1 % 3;
    
85.                 }
    
86.                 for(j=0; j<a; j++)
    
87.             {
    
88.                     Pop(&s1,&e);
    
89.                     sum1=sum1+(e-48)*pow(2,j);
    
90.                 }
    
91.                 sum=sum1+48;
    
92.                 sum1=0;
    
93.                 Push(&s2,sum);
    
94.         }
    
95.        
    
96.         len2=Stacksize(s2);
    
97.         printf("转换为八进制为：");
    
98.         for(k=0; k<len2 ;k++)
    
99.         {
    
100.                 Pop(&s2,&sum);
     
101.                 printf("%c",sum);
     
102.         }
     
103.        
     
104.         return 0;
     
105. }

复制代码

我叫淳子

关于16进制，只要把代码稍稍改动就可以，就是八进制是3位，十六进制是4位，看过视频的应该懂。

xiaozhi7713

看看哦！

SDULZY

谢谢分享！

zerohk

1. #include <stdio.h>
   
2. #include <malloc.h>
   
3. #include <stdlib.h>
   
4. #include<math.h>
   
5. 
   
6. 
   
7. #define INIT_STACK_SIZE 20
   
8. #define STACKINCREMENT 10
   
9. 
   
10. typedef char ElemType;
    
11. 
    
12. typedef struct {
    
13.     ElemType *base;
    
14.     ElemType *top;
    
15.     int stackSize;
    
16. 
    
17. }seStack;
    
18. 
    
19. void initStack(seStack *s);
    
20. void push(seStack *s,ElemType e);
    
21. void pop(seStack *s,ElemType *e);
    
22. int stackLen(seStack s);
    
23. int main() {
    
24. seStack s2,s3;
    
25.     initStack(&s2);
    
26.     initStack(&s3);
    
27.     printf("请输入你想要转化的二进制数：输入'#'结束");
    
28.     ElemType c1;
    
29.     scanf("%c",&c1);
    
30.     while(c1 != '#')
    
31.     {
    
32.         push(&s2,c1);
    
33.         scanf("%c",&c1);
    
34.     }
    
35.     getchar();
    
36.     int i;
    
37.     if(stackLen(s2) % 3 == 0)
    
38.     {
    
39.         i = stackLen(s2)/3;
    
40.     } else
    
41.         i = stackLen(s2)/3 + 1;
    
42.     for(;i>0;i--)
    
43.     {
    
44.         ElemType mid = 0;
    
45.         ElemType rval;
    
46.         for(int j = 0;j<3;j++)
    
47.         {
    
48.             if(s2.base == s2.top)
    
49.             {
    
50.                 rval = '0';
    
51.             }
    
52.            else
    
53.                 pop(&s2,&rval);
    
54.             mid += (rval-48) * pow(2,j);
    
55.         }
    
56.         push(&s3,mid);
    
57.     }
    
58.     printf("转化后的八进制数是：");
    
59.     ElemType val;
    
60.     while (s3.top != s3.base)
    
61.     {
    
62.         pop(&s3,&val);
    
63.         printf("%d",val);
    
64.     }
    
65. 
    
66.     return 0;
    
67. }
    
68. 
    
69. 
    
70. 
    
71. void initStack(seStack *s)
    
72. {
    
73.     s->base = (ElemType *)malloc(sizeof(ElemType));
    
74.     if(!s->base)
    
75.         exit(0);
    
76.     s->top = s->base;
    
77.     s->stackSize = INIT_STACK_SIZE;
    
78. }
    
79. 
    
80. void push(seStack *s,ElemType e)
    
81. {
    
82.     if(s->top - s->base >= s->stackSize)
    
83.     {
    
84.         s->base = (ElemType *)realloc(s->base,(s->stackSize + STACKINCREMENT) * sizeof(ElemType));
    
85.         s->top = s->base + s->stackSize;
    
86.         s->stackSize = s->stackSize + STACKINCREMENT;
    
87.     }
    
88.     *(s->top) = e;
    
89.     s->top++;
    
90. }
    
91. 
    
92. void pop(seStack *s,ElemType *e)
    
93. {
    
94.     if(s->top == s->base)
    
95.         return;
    
96.     *e = *--(s->top);
    
97. }
    
98. 
    
99. int stackLen(seStack s)
    
100. {
     
101.     return (s.top - s.base);
     
102. }

复制代码

这样不知道可不可以。算了几个是对的，就是不知道有没有啥逻辑错误

GlaXYDSK

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #include<math.h>
   
4. #define Stack_size 20
   
5. #define Stackinrement 10
   
6. typedef char Elemtype;
   
7. typedef struct{
   
8.     Elemtype *bottom ;
   
9.     Elemtype *top;
   
10.     int Stacksize;
    
11.   }sqstack;
    
12.   
    
13.   
    
14. void initstack(sqstack *s)
    
15. {
    
16.    s->bottom=(Elemtype*)malloc((Stack_size)*sizeof(Elemtype));
    
17.    if(!s->bottom)
    
18.    {exit(0);}
    
19.    s->top=s->bottom;
    
20.    s->Stacksize= Stack_size;
    
21. }
    
22. 
    
23. void push(sqstack *s,Elemtype e)
    
24. {
    
25.       if((s->top-s->bottom)>=s->Stacksize-1)
    
26.       {s->bottom=(Elemtype*)realloc(s->bottom,(s->Stacksize+Stackinrement)*sizeof(Elemtype))    ;
    
27.       if(!s->bottom)
    
28.        {exit(0);}
    
29.         s->top=s->bottom+Stackinrement;
    
30.        s->Stacksize=s->Stacksize+Stackinrement;
    
31.       }
    
32.     *s->top= e  ;
    
33.     s->top++;
    
34. 
    
35. }
    
36. 
    
37. 
    
38. 
    
39. void pop(sqstack *s,Elemtype *e)
    
40. {
    
41. if(s->top==s->bottom)
    
42. {exit(0);}
    
43.   s->top--;
    
44.   *e=*s->top;
    
45. 
    
46. 
    
47. }
    
48. 
    
49. int stacklen(sqstack s)
    
50. {return  (s.top-s.bottom)  ;
    
51. }
    
52. 
    
53. int main()
    
54. { Elemtype c;
    
55.    sqstack s,s1;
    
56.    initstack(&s);
    
57.    initstack(&s1);
    
58.    printf ("输入二进制数,输入#代表结束");
    
59.     scanf("%c",&c);
    
60.     while(c!='#')
    
61.     {
    
62. 
    
63.         push(&s,c) ;
    
64.         scanf("%c",&c);
    
65. 
    
66.     }
    
67.     getchar();
    
68.         int len= stacklen(s);
    
69.         char sum;
    
70.         int len1=len/3;
    
71.         int a=len%3;
    
72.         int j=0;
    
73.         printf("当前栈容量为%d\n",len);
    
74.         for(int i=0;i<len1;i++)
    
75.         {
    
76.                 for(j=0;j<3;j++)
    
77.                         {
    
78.                         pop(&s,&c);
    
79.                 sum=sum+pow(2,j)*(c-48);   
    
80.                         }
    
81.                         j=0;
    
82.                         sum=sum+48;
    
83.                         push(&s1,sum);
    
84.             sum=0;
    
85.         }
    
86.         if(a!=0)
    
87.         {
    
88.                 for(int k=0;k<a;k++)
    
89.                 {
    
90.                 sum=sum+pow(2,k)*(c-48);
    
91.                
    
92.                         }
    
93.                         len1=len1+1;
    
94.                         push(&s1,sum);
    
95.                 }
    
96.                
    
97.                 printf("转化结果为");
    
98.                 for(int i=0;i<len1;i++)
    
99.                 {
    
100.                  
     
101.                  pop(&s1,&sum);
     
102.                  printf("%c",sum);
     
103.                
     
104.                 }
     
105.                  printf("\n");
     
106. 
     
107.    return 0;

复制代码

大部分参考了视频教学，改的有点乱，能跑就懒得动了
大概的想法就是第一个s堆完了以后，先把不一定能凑成三个的顶部元素拿掉，再三个三个弹出来加完推到s1里，最后判断要不要推一次顶上的几个元素和
最后的sum跑出来才忘记加48了，