二进制，八进制，十六进制和十进制的转换程序

              最近用数据结构中栈的知识弄了个进制转换的程序。

              大家看看。

/*

*这个程序实现了十进制与二进制，八进制，十六进制之间的转换。

*Dec stand for decimal

*Oct stand for octonary

*Bin stand for binary

*/

/*

*author:xufeiyang

*version: v1.0

*/

#include <stdio.h>

#include <math.h>

#define MAXSIZE 16

typedef struct stack                       /*栈结构声明*/

{

    short int pool[MAXSIZE];

    short int top;

}Stack;

void InitStack(Stack *bin)        /*初始化栈，将其中值都赋值0，方便以后操作*/

{

    int i;

    for(i = 0; i < MAXSIZE; i++)

        bin->pool[i] = 0;

    bin->top = -1;

}

int IsEmpty(Stack *bin)        /*判断栈是否是空栈;若是，返回*/

{

    if(-1 == bin->top)

        return 1;

    else

        return 0;

}

int GetTopElem(Stack *sta)        /*取得栈顶元素*/

{

    return sta->pool[sta->top];

}

int Push(Stack *bin, short int x)        /*元素x入栈*/

{

    if(bin->top == MAXSIZE-1)

        return 0;

    bin->top++;

    bin->pool[bin->top] = x;

    return 1;

}

int Pop(Stack *bin, short int *x)                  /*出栈，元素存入x中返回*/

{

    if(-1 == bin->top)

        return 0;

    else

    {

        *x = bin->pool[bin->top];

        bin->top--;

        return 1;

    }

}

void DecToBin(int decnum, Stack *bin)        /*将十进制转换成二进制*/

{

    short int numinstack;            /*用来接收栈中弹出的元素*/

    Stack temp;            /*定义一个栈，用来最为二进制转换的中间栈，临时存储*/

    InitStack(&temp);

    if(0 == decnum)            /*输入的十进制数是0，则直接将0压入栈，继续往栈中压入0直至栈满*/

    {

        Push(bin, 0);

        bin->top = 15;

        return;

    }

    if(decnum > 0)            /*输入的十进制数是正数*/

    {

        while(decnum != 0)

        {

            Push(bin, decnum % 2);

            decnum /= 2;

        }

        bin->top = 15;

    }

    if(decnum < 0)            /*输入的十进制数是负数，先按正数操作，最后压1入栈，表示负号*/

    {

        decnum = -decnum;

        while(decnum != 0)

        {

            Push(bin ,decnum % 2);

            decnum /= 2;

        }

        bin->top = 14;

        while(!IsEmpty(bin))    /*转换后，temp中的数是十进制负数的反码，此时二进制正序排列*/

        {

            Pop(bin, &numinstack);

            if(1 == numinstack)

                Push(&temp, 0);

            else

                Push(&temp, 1);

        }

        temp.pool[temp.top]++;    /*栈顶元素加1，其实是为反码转换成补码做准备*/

        while(!IsEmpty(&temp))    /*将反码转换成补码*/

        {

            Pop(&temp, &numinstack);

            if(2 == numinstack)

            {

                Push(bin, 0);

                temp.pool[temp.top]++;

            }

            else

            {

                Push(bin, numinstack);

            }

        }

        Push(bin, 1);   /*最后压1入栈，表示该数是负数*/

    }

}

void DecToHex(int decnum, Stack *hex)    /*十进制转换成十六进制*/

{

    Stack bin;                /*定义一个二进制栈，十进制先转换成二进制*/

    Stack temp;

    int i = 0;

    short int tempnum;

    int sum = 0;

    InitStack(&bin);

    InitStack(&temp);

    DecToBin(decnum, &bin);

    while(!IsEmpty(&bin))        /*将bin中二进制码倒置在temp中*/

    {

        Pop(&bin, &tempnum);

        Push(&temp, tempnum);

    }

    while(!IsEmpty(&temp))

    {

        Pop(&temp, &tempnum);

        sum += tempnum * pow(2, i);

        i++;

        if(4 == i)

        {

            Push(hex, sum);

            sum = 0;

            i = 0;

        }

    }

/*    while(decnum != 0)

    {

        Push(hex, decnum % 16);

        decnum /= 16;

    }

*/

}

void DecToOct(int decnum, Stack *oct)        /*十进制转换成八进制*/

{

    Stack bin;

    Stack temp;

    int i = 0, sum = 0;

    short int tempnum;

    InitStack(&bin);

    InitStack(&temp);

    DecToBin(decnum, &bin);

    while(!IsEmpty(&bin))

    {

        Pop(&bin, &tempnum);

        Push(&temp , tempnum);

    }

    while(!IsEmpty(&temp))

    {

        Pop(&temp, &tempnum);

        sum += tempnum * pow(2, i);

        i++;

        if(3 == i)

        {

            Push(oct, sum);

            sum = 0;

            i = 0;

        }

    }

    if(decnum >= 0)

        Push(oct, 0);

    else

        Push(oct, 1);

}

int BinToDec(Stack *bin)    /*二进制转换成十进制*/

{

    int DecNum = 0;

    int i = MAXSIZE - 2;

    short int  popnum;

    Stack temp;

    InitStack(&temp);

    if(1 == GetTopElem(bin))    /*如果符号位是1*/

    {

        while(!IsEmpty(bin))    /*Exchange*/

        {

            Pop(bin, &popnum);

            Push(&temp, popnum);

        }

        temp.pool[temp.top]--;

        while(!IsEmpty(&temp))     /*fushu buma zhuanghuancheng fanma*/

        {

            Pop(&temp, &popnum);

            if(-1 == popnum)

            {

                Push(bin, 1);

                temp.pool[temp.top]--;

            }

            else

            {

                Push(bin, popnum);

            }

        }

        while(!IsEmpty(bin))      /*fanma zhuanhuancheng yuanma*/

        {

            Pop(bin, &popnum);

            if(1 == popnum)

                Push(&temp, 0);

            else

                Push(&temp, 1);

        }

        i = 0;

        while(!IsEmpty(&temp))

        {

            Pop(&temp, &popnum);

            DecNum += popnum * pow(2, i);

            i++;

        }

        return -DecNum;

    }

    Pop(bin, &popnum);    /*弹出符号位0*/

    while(!IsEmpty(bin))    /*二进制是正数*/

    {

        Pop(bin, &popnum);

        DecNum += popnum * pow(2, i);

        i--;

    }

    return DecNum;

}

void OctToBin(Stack *oct, Stack *bin)        /*八进制转换成二进制*/

{

    short int popnum;

    Stack temp;

    InitStack(&temp);

    Pop(oct, &popnum);

    Push(&temp, popnum);

    while(!IsEmpty(oct))

    {

        Pop(oct, &popnum);

        switch(popnum)

        {

            case 0:

                Push(&temp, 0);

                Push(&temp, 0);

                Push(&temp, 0);

                break;

            case 1:

                Push(&temp, 0);

                Push(&temp, 0);

                Push(&temp, 1);

                break;

            case 2:

                Push(&temp, 0);

                Push(&temp, 1);

                Push(&temp, 0);

                break;

            case 3:

                Push(&temp, 1);

                Push(&temp, 1);

                Push(&temp, 0);

                break;

            case 4:

                Push(&temp, 1);

                Push(&temp, 0);

                Push(&temp, 0);

                break;

            case 5:

                Push(&temp, 1);

                Push(&temp, 0);

                Push(&temp, 1);

                break;

            case 6:

                Push(&temp, 1);

                Push(&temp, 1);

                Push(&temp, 0);

                break;

            case 7:

                Push(&temp, 1);

                Push(&temp, 1);

                Push(&temp, 1);

                break;

        }

    }

    while(!IsEmpty(&temp))    /*将temp中的二进制码倒置压入bin栈中*/

    {

        Pop(&temp, &popnum);

        Push(bin, popnum);

    }

}

void HexToBin(Stack *hex, Stack *bin)        /*十六进制转换成二进制*/

{

    short int popnum;

    Stack temp;

    InitStack(&temp);

    while(!IsEmpty(hex))

    {

        Pop(hex, &popnum);

        switch(popnum)

        {

            case 0:

                Push(&temp, 0);

                Push(&temp, 0);

                Push(&temp, 0);

                Push(&temp, 0);

                break;

            case 1:

                Push(&temp, 0);

                Push(&temp, 0);

                Push(&temp, 0);

                Push(&temp, 1);

                break;

            case 2:

                Push(&temp, 0);

                Push(&temp, 0);

                Push(&temp, 1);

                Push(&temp, 0);

                break;

            case 3:

                Push(&temp, 0);

                Push(&temp, 0);

                Push(&temp, 1);

                Push(&temp, 1);

                break;

            case 4:

                Push(&temp, 0);

                Push(&temp, 1);

                Push(&temp, 0);

                Push(&temp, 0);

                break;

            case 5:

                Push(&temp, 0);

                Push(&temp, 1);

                Push(&temp, 0);

                Push(&temp, 1);

                break;

            case 6:

                Push(&temp, 0);

                Push(&temp, 1);

                Push(&temp, 1);

                Push(&temp, 0);

                break;

            case 7:

                Push(&temp, 0);

                Push(&temp, 1);

                Push(&temp, 1);

                Push(&temp, 1);

                break;

            case 8:

                Push(&temp, 1);

                Push(&temp, 0);

                Push(&temp, 0);

                Push(&temp, 0);

                break;

            case 9:

                Push(&temp, 1);

                Push(&temp, 0);

                Push(&temp, 0);

                Push(&temp, 1);

                break;

            case 10:

                Push(&temp, 1);

                Push(&temp, 0);

                Push(&temp, 1);

                Push(&temp, 0);

                break;

            case 11:

                Push(&temp, 1);

                Push(&temp, 0);

                Push(&temp, 1);

                Push(&temp, 1);

                break;

            case 12:

                Push(&temp, 1);

                Push(&temp, 1);

                Push(&temp, 0);

                Push(&temp, 0);

                break;

            case 13:

                Push(&temp, 1);

                Push(&temp, 1);

                Push(&temp, 0);

                Push(&temp, 1);

                break;

            case 14:

                Push(&temp, 1);

                Push(&temp, 1);

                Push(&temp, 1);

                Push(&temp, 0);

                break;

            case 15:

                Push(&temp, 1);

                Push(&temp, 1);

                Push(&temp, 1);

                Push(&temp, 1);

                break;

        }

    }

    while(!IsEmpty(&temp))        /*将temp中的二进制码倒置压入bin中*/

    {

        Pop(&temp, &popnum);

        Push(bin, popnum);

    }

}

int OctToDec(Stack *oct)        /*八进制通过二进制转换成十进制*/

{

    Stack bin;

    int DecNum;

    InitStack(&bin);

    OctToBin(oct, &bin);

    DecNum = BinToDec(&bin);

    return DecNum;

}

int HexToDec(Stack *hex)        /*十六进制通过二进制转换成十进制*/

{

    Stack bin;

    int DecNum;

    InitStack(&bin);

    HexToBin(hex, &bin);

    DecNum = BinToDec(&bin);

    return DecNum;

}

int TranslateToHex(Stack *hex, char hexpool[], int size)    /*将输入的十六进制字符，转换成十六进制数字，并存入栈hex中*/

{

    int i;

    for(i = size - 1; i >= 0; i--)

    {

        switch(hexpool[i])

        {

            case 'A':

            case 'a':

                Push(hex, 10);

                break;

            case 'B':

            case 'b':

                Push(hex, 11);

                break;

            case 'C':

            case 'c':

                Push(hex, 12);

                break;

            case 'D':

            case 'd':

                Push(hex, 13);

                break;

            case 'E':

            case 'e':

                Push(hex, 14);

                break;

            case 'F':

            case 'f':

                Push(hex, 15);

                break;

            case '0':

            case '1':

            case '2':

            case '3':

            case '4':

            case '5':

            case '6':

            case '7':

            case '8':

            case '9':

                Push(hex, hexpool[i] - 48);

                break;

            default:

                printf("Hex number is Wrong!/n");

                return -1;

        }

    }

}

int TranslateToBin(Stack *bin, char binpool[], int size)    /*将输入的二进制字符转换成二进制数字，并存入栈bin中*/

{

    int i;

    for(i = size - 1; i >= 0; i--)

    {

        if('1' == binpool[i])

        {

            Push(bin, 1);

        }

        else if('0' == binpool[i])

        {

            Push(bin, 0);

        }

        else

        {

            printf("Bin Number is Wrong! /n");

            return -1;

        }

    }

}

int TranslateToOct(Stack *oct, char octpool[], int size)    /*将输入的八进制字符转换成八进制数字，并存入栈oct中*/

{

    int i;

    int popnum;

    if('0' != octpool[0] && '1' != octpool[0])

    {

        printf("Oct number is Wrong!/n");

        return -1;

    }

    for(i = size - 1; i >= 0; i--)

    {

        if(octpool[i] > '7' || octpool[i] < '0')

        {

            printf("Oct number is Wrong!/n");

            return -1;

        }

        Push(oct, octpool[i] - 48);

    }

}

void PrintHex(Stack *hex)        /*按十六进制形式打印*/

{

    short int tempnum;

    while(!IsEmpty(hex))

    {

        Pop(hex, &tempnum);

        switch(tempnum)

        {

        case 10:

            putchar('A');

            break;

        case 11:

            putchar('B');

            break;

        case 12:

            putchar('C');

            break;

        case 13:

            putchar('D');

            break;

        case 14:

            putchar('E');

            break;

        case 15:

            putchar('F');

            break;

        default:

            printf("%d", tempnum);

            break;

        }

    }

}

int main()

{

    Stack bin;        /*二进制栈*/

    Stack hex;    /*十六进制栈*/

    Stack oct;    /*八进制栈*/

    int DecNum;    /*输入和输出的十进制*/

    short int tempnum;    /*接收bin中弹出的数字*/

    int choice;    /*选项*/

    char binpool[MAXSIZE];    /*接收16个二进制字符*/

    char octpool[6];        /*接收6个八进制字符*/

    char hexpool[4];        /*接收4个十六进制字符*/

    clrscr();

    memset(binpool, '0', MAXSIZE);    /*将binpool内存块所有空间赋值为‘0’*/

    memset(octpool, '0', 6);

    memset(hexpool, '0', 4);

    while(1)

    {

        InitStack(&bin);

        InitStack(&hex);

        InitStack(&oct);

        printf("/n========== Menu ===========/n");

        printf("  1.---- Dec to Bin ----/n");

        printf("  2.---- Dec to Oct ----/n");

        printf("  3.---- Dec to Hex ----/n");

        printf("  4.---- Bin to Dec ----/n");

        printf("  5.---- Oct to Dec ----/n");

        printf("  6.---- Hex to Dec ----/n");

        printf("  7.---- Exit ----/n");

        putchar('/n');

        printf("Choose : ");

        scanf("%d", &choice);

        getchar();

        switch(choice)

        {

            case 1:

                clrscr();

                printf("Please input a dec Number : ");

                scanf("%d", &DecNum);

                getchar();

                DecToBin(DecNum, &bin);

                printf("Dec to Bin is : ");

                while(!IsEmpty(&bin))

                {

                   Pop(&bin, &tempnum);

                   printf("%d", tempnum);

                }

                putchar('/n');

                break;

            case 2:

                clrscr();

                printf("Enter a Dec number : ");

                scanf("%d", &DecNum);

                getchar();

                DecToOct(DecNum, &oct);

                printf("Dec to Oct is : 0o");

                while(!IsEmpty(&oct))

                {

                    Pop(&oct, &tempnum);

                    printf("%d", tempnum);

                }

                putchar('/n');

                break;

            case 3:

                clrscr();

                printf("Enter a Dec number : ");

                scanf("%d", &DecNum);

                getchar();

                DecToHex(DecNum, &hex);

                printf("Dec to Hex is : 0x");

                PrintHex(&hex);

                putchar('/n');

                break;

            case 4:

                clrscr();

                printf("Enter a 16 bit Bin number : ");

                scanf("%s", binpool);

                getchar();

                if(-1 == TranslateToBin(&bin, binpool, MAXSIZE))

                {

                    break;

                }

                DecNum = BinToDec(&bin);

                printf("Answer (Dec) is : %d/n", DecNum);

                break;

            case 5:

                clrscr();

                printf("Enter a 6 bit Oct number : ");

                scanf("%s", octpool);

                getchar();

                if(-1 == TranslateToOct(&oct, octpool, 6))

                {

                    break;

                }

                DecNum = OctToDec(&oct);

                printf("Answer (Dec) is : %d/n", DecNum);

                break;

            case 6:

                clrscr();

                printf("Enter a 4 bit Hex number : 0x");

                scanf("%s", hexpool);

                getchar();

                if(-1 == TranslateToHex(&hex, hexpool, 4))

                {

                    break;

                }

                DecNum = HexToDec(&hex);

                printf("Answer (Dec) is : %d/n", DecNum);

                break;

            case 7:

                system("PAUSE");

                return 0;

            default:

                printf("Error , Choose again !/n");

                break;

        }

    }

    putchar('/n');

}

写得比较长，主要原因是我写完以后没有对代码和算法进行优化，有兴趣的话，可以和我讨论下如何优化，呵呵

哦，忘了说用的IDE是Turbo C。