C语言数据结构之利用栈机制写的进制转换器

最新推荐文章于 2022-04-08 10:48:15 发布

超大板栗

最新推荐文章于 2022-04-08 10:48:15 发布

阅读量849

点赞数

分类专栏： C/C++

本文链接：https://blog.csdn.net/a1135004584/article/details/79356774

版权

C/C++ 专栏收录该内容

26 篇文章 1 订阅

订阅专栏

将各个进制转换重新整理了以下，用栈的灵活机制写了一个进制转换器。

图：

代码：Stack.h

#ifndef _STACK_H_
#define _STACK_H_

#include <stdbool.h>
#define STACK_INIT_SIZE 100 //栈控件初始化大小
#define STACK_INCREMENT 10 //栈控件增量

typedef struct{
    void * base;//栈底
    void * top;//栈顶
    int stackSize;//当前已经分配的存储空间
    int elementLength;
}SqStack;

typedef enum{
    FAILED,SUCCESS
}Status;

Status initStack(SqStack * pStack,int elength);

void destroyStack(SqStack * pStack);
void clearStack(SqStack * pStack);//将栈置空
bool stackIsEmpty(SqStack * pStack);
int stackLength(const SqStack * pStack);
void * getTop(SqStack * pStack);
void push(SqStack * pStack,void *data);//压栈
void pop(SqStack * pStack,void *data);//出栈,若不空删除栈顶元素并将其值返回

void * get(SqStack * pStack,int i);//获取栈的第i个位置的元素

/**
 * 输出栈中每个元素，如果direction为正则从头到尾输出，反之从尾到头输出.
 * @param pStack
 * @param pfun
 * @param direction
 */
void stackTraverse(SqStack * pStack,void(*pfun)(void *),int direction);

#endif

Stack.c

#include <malloc.h>
#include <memory.h>
#include <assert.h>
#include "Stack.h"

Status initStack(SqStack * pStack,int elength)
{

    pStack->base = malloc((size_t) (elength * STACK_INIT_SIZE));
    if(!pStack->base)//如果分配内存失败
        return FAILED;

    pStack->elementLength = elength;
    pStack->top = pStack->base;
    pStack->stackSize = STACK_INIT_SIZE;

    return SUCCESS;
}

void destroyStack(SqStack * pStack)
{
    if(pStack)
    {
        free(pStack->base);
        pStack->base = NULL;
        pStack->top = NULL;
        pStack->stackSize = 0;
    }

}

void clearStack(SqStack * pStack)//将栈置空
{
    if(pStack)
        pStack->top = pStack->base;
}

bool stackIsEmpty(SqStack * pStack)
{
    if(pStack)
    {
        if(pStack->top == pStack->base)
            return true;
        else
            return false;
    }

    return false;
}

/**
 * 返回栈当前长度
 * 用栈顶减去栈底除以单个元素大小即可.
 * @param pStack
 * @return
 */
int stackLength(const SqStack * pStack)
{
    return (int) (pStack->top - pStack->base)/pStack->elementLength;
}

void * getTop(SqStack * pStack)
{
    if(pStack->top == pStack->base)
        return NULL;
    else
        return pStack->top;
}

void push(SqStack * pStack,void *data)//压栈
{

    if((pStack->top - pStack->base)/pStack->elementLength >= pStack->stackSize)
    {
        pStack->base =
                realloc(pStack->base,
                        (size_t) ((pStack->stackSize + STACK_INCREMENT)*pStack->elementLength));

        assert(pStack->base != NULL);
        pStack->top = pStack->base+pStack->stackSize*pStack->elementLength;
        pStack->stackSize += STACK_INCREMENT;
    }
    memcpy(pStack->top, data, (size_t) pStack->elementLength);

    pStack->top = pStack->top+pStack->elementLength;
}

void pop(SqStack * pStack,void *data)//出栈,若不空删除栈顶元素并将其值返回
{
    if(pStack->top != pStack->base)
    {
        if(data)
            memcpy(data,pStack->top,(size_t)pStack->elementLength);
        pStack->top -= pStack->elementLength;
    }
}


void * get(SqStack * pStack,int i)//获取栈的第i个位置的元素
{
    void * pn = NULL;

    if(stackLength(pStack) != 0)
        pn = &pStack->base[i];

    return pn;
}


/**
 *
 * @param pStack
 * @param pfun
 * @param direction 遍历方向
 * @param isHex 是否是16进制
 */
void stackTraverse(SqStack * pStack,void(*pfun)(void *),int direction)
{
    void * pd = NULL;
    if(direction > 0)
    {
        pd = pStack->base;

        while(pd < pStack->top)
        {
            pfun(pd);
            pd += pStack->elementLength;
        }
    }else{
        pd = pStack->top;

        while(pd > pStack->base)
        {
            pd -= pStack->elementLength;
            pfun(pd);
        }
    }

}

converstion.h

#ifndef _CONVERSION_H_
#define _CONVERSION_H_
#include "Stack.h"

//二进制转八进制
void bin2Otc(SqStack *sqStack,SqStack *sqStack1);
//二进制转十进制
void bin2Dec(SqStack *sqStack,SqStack *sqStack1);
//二进制转十六进制
void bin2Hex(SqStack *sqStack,SqStack *sqStack1);

//八进制转二进制
void otc2Bin(SqStack *sqStack,SqStack *sqStack1);
//八进制转十进制
void otc2Dec(SqStack *sqStack,SqStack *sqStack1);
//八进制转十六进制
void otc2Hex(SqStack *sqStack,SqStack *sqStack1);

//十进制转二进制
void dec2Bin(SqStack *sqStack,SqStack *sqStack1);
//十进制转八进制
void dec2Otc(SqStack *sqStack,SqStack *sqStack1);
//十进制转十六进制
void dec2Hex(SqStack *sqStack,SqStack *sqStack1);

//十六进制转二进制
void hex2Bin(SqStack *sqStack,SqStack *sqStack1);
//十六进制转八进制
void hex2Otc(SqStack *sqStack,SqStack *sqStack1);
//十六进制转十进制
void hex2Dec(SqStack *sqStack,SqStack *sqStack1);

#endif

converstion.c

#include "converstion.h"
#include <math.h>

//二进制转八进制
void bin2Otc(SqStack *sqStack,SqStack *sqStack1)
{
    int m,n,i,j,k=3,temp,sum=0;
    m = stackLength(sqStack);
    void * pn = sqStack->top;


    n = m % 3;
    m /= k;

    for(i=0;i<m;i++)
    {
        for(j=0;j<k;j++)
        {
            pn -= sqStack->elementLength;
            temp = *(int *)pn;
            sum += temp * pow(2,j);
        }
        push(sqStack1,&sum);
        sum = 0;
    }

    for(i=0;i<n;i++)
    {
        pn -= sqStack->elementLength;
        temp = *(int *)pn;
        sum += temp * pow(2,i);
    }
    push(sqStack1,&sum);

}
//二进制转十进制
void bin2Dec(SqStack *sqStack,SqStack *sqStack1)
{
    int m,i,sum=0,temp;

    m = stackLength(sqStack);
    void * pn = sqStack->top;

    for(i=0;i<m;i++)
    {
        pn -= sqStack->elementLength;
        temp = *(int *)pn;
        sum += temp * pow(2,i);
    }
    push(sqStack1,&sum);
}
//二进制转十六进制
void bin2Hex(SqStack *sqStack,SqStack *sqStack1)
{
    int m,n,i,j,k=4,temp,sum=0;
    m = stackLength(sqStack);
    void * pn = sqStack->top;


    n = m % 3;
    m /= k;

    for(i=0;i<m;i++)
    {
        for(j=0;j<k;j++)
        {
            pn -= sqStack->elementLength;
            temp = *(int *)pn;
            sum += temp * pow(2,j);
        }
        push(sqStack1,&sum);
        sum = 0;
    }

    for(i=0;i<n;i++)
    {
        pn -= sqStack->elementLength;
        temp = *(int *)pn;
        sum += temp * pow(2,i);
    }
    push(sqStack1,&sum);
}

//八进制转二进制
void otc2Bin(SqStack *sqStack,SqStack *sqStack1)
{
    int i,j,k=0,m,n;
    void * pn = sqStack->top;
    m = stackLength(sqStack);

    for(i=0;i<m;i++)
    {
        pn -= sqStack->elementLength;
        n = *(int *)pn;

        while(n){
            j = n % 2;
            push(sqStack1,&j);
            k++;
            n /= 2;
        }

        j=0;
        while(k<3)
        {
            push(sqStack1,&j);
            k++;
        }
        k=0;
    }
}

//八进制转十进制
void otc2Dec(SqStack *sqStack,SqStack *sqStack1)
{
    int i,m,temp,sum=0;

    m = stackLength(sqStack);
    void * pn = sqStack->top;


    for(i=0;i<m;i++)
    {
        pn -= sqStack->elementLength;
        temp = *(int *)pn;
        sum += temp * pow(8,i);
    }

    push(sqStack1,&sum);
}
//八进制转十六进制
void otc2Hex(SqStack *sqStack,SqStack *sqStack1)
{
    SqStack stackTemp;

    initStack(&stackTemp,sizeof(int));

    otc2Bin(sqStack,&stackTemp);//将八进制转换为二进制

    int i,j,k=4,m,n,temp,sum=0;
    void * pn = stackTemp.base;
    m = stackLength(&stackTemp);

    j = m % k;
    m /= k;

    for(i=0;i<m;i++)
    {
        for(n=0;n<k;n++)
        {
            temp = *(int *)pn;
            sum += temp * pow(2,n);
            pn += stackTemp.elementLength;
        }
        push(sqStack1,&sum);
        sum = 0;
    }

    for(i=0;i<j;i++)
    {
        temp = *(int *)pn;
        sum += temp * pow(2,i);
        pn += stackTemp.elementLength;
    }
    push(sqStack1,&sum);

    destroyStack(&stackTemp);
}
//十进制转二进制
void dec2Bin(SqStack *sqStack,SqStack *sqStack1)
{
    int i,j,m,sum=0;

    m = stackLength(sqStack);

    void * pn = sqStack->top;

    for(i=0;i<m;i++)
    {
        pn -= sqStack->elementLength;
        sum += *(int *)pn * pow(10,i);
    }

    while(sum)
    {
        j = sum % 2;
        push(sqStack1,&j);
        sum /= 2;
    }

}
//十进制转八进制
void dec2Otc(SqStack *sqStack,SqStack *sqStack1)
{
    int i,j,m,sum=0;

    m = stackLength(sqStack);

    void * pn = sqStack->top;

    for(i=0;i<m;i++)
    {
        pn -= sqStack->elementLength;
        sum += *(int *)pn * pow(10,i);
    }

    while(sum)
    {
        j = sum % 8;
        push(sqStack1,&j);
        sum /= 8;
    }
}
//十进制转十六进制
void dec2Hex(SqStack *sqStack,SqStack *sqStack1)
{
    int i,j,m,sum=0;

    m = stackLength(sqStack);

    void * pn = sqStack->top;

    for(i=0;i<m;i++)
    {
        pn -= sqStack->elementLength;
        sum += *(int *)pn * pow(10,i);
    }

    while(sum)
    {
        j = sum % 16;
        push(sqStack1,&j);
        sum /= 16;
    }
}

//十六进制转二进制
void hex2Bin(SqStack *sqStack,SqStack *sqStack1)
{
    int i,j,k=0,m,n;
    void * pn = sqStack->top;
    m = stackLength(sqStack);

    for(i=0;i<m;i++)
    {
        pn -= sqStack->elementLength;
        n = *(int *)pn;

        while(n){
            j = n % 2;
            push(sqStack1,&j);
            k++;
            n /= 2;
        }

        j=0;
        while(k<4)
        {
            push(sqStack1,&j);
            k++;
        }
    }
}
//十六进制转八进制
void hex2Otc(SqStack *sqStack,SqStack *sqStack1)
{
    SqStack stackTemp;

    initStack(&stackTemp,sizeof(int));

    hex2Bin(sqStack,&stackTemp);

    int i,j,m,n,temp,sum=0;
    void * pn = stackTemp.base;

    m = stackLength(&stackTemp);

    j = m % 3;
    m /= 3;

    for(i=0;i<m;i++)
    {
        for(n=0;n<3;n++)
        {

            temp = *(int *)pn;
            sum += temp * pow(2,n);
            pn += stackTemp.elementLength;
        }
        push(sqStack1,&sum);

        sum = 0;
    }

    for(i=0;i<j;i++)
    {
        temp = *(int *)pn;
        sum += temp * pow(2,i);
        pn += stackTemp.elementLength;

    }

    push(sqStack1,&sum);

    destroyStack(&stackTemp);
}
//十六进制转十进制
void hex2Dec(SqStack *sqStack,SqStack *sqStack1)
{
    int i,m,temp,sum=0;

    m = stackLength(sqStack);
    void * pn = sqStack->top;


    for(i=0;i<m;i++)
    {
        pn -= sqStack->elementLength;
        temp = *(int *)pn;
        sum += temp * pow(16,i);
    }

    push(sqStack1,&sum);
}

main.c

#include <stdio.h>
#include "Stack.h"
#include "converstion.h"

void pfun(void * parm);
//测试用例
void test();

//打印选项列表
void conver_print();


void input_value(SqStack *ptr);

void bin2ODH(SqStack *ptr, SqStack *ptr1);

void otc2BDH(SqStack *ptr, SqStack *ptr1);

void hex2BOD(SqStack *ptr, SqStack *ptr1);

void dec2BOH(SqStack *ptr, SqStack *ptr1);

void conver_choose()
;

int main() {

    conver_choose();
    return 0;
}

void pfun(void * parm)
{
    if(*(int *)parm == 10)
    {
        printf("A");
    }else if(*(int *)parm == 11)
    {
        printf("B");
    }else if(*(int *)parm == 12)
    {
        printf("C");
    }else if(*(int *)parm == 13)
    {
        printf("D");
    }else if(*(int *)parm == 14)
    {
        printf("E");
    }else if(*(int *)parm == 15)
    {
        printf("F");
    }else{
        printf("%d",*(int *)parm);
    }
}


void conver_print()
{
    printf("-----------------选项-------------------\n");
    printf("0.2进制转 8 10 16进制\n");
    printf("1.8进制转 2 10 16进制\n");
    printf("2.10进制转 2 8 16进制\n");
    printf("3.16进制转 2 8 10进制\n");
    printf("---------------------------------------\n");
}

void conver_choose()
{
    conver_print();
    SqStack sqStack1,sqStack2;
    int d;

    initStack(&sqStack1,sizeof(int));
    initStack(&sqStack2,sizeof(int));

    do{
        printf("请输入选项:");
        scanf("%d",&d);
        getchar();

        input_value(&sqStack1);
        switch(d)
        {
            case 0://2进制转 8 10 16进制
                bin2ODH(&sqStack1,&sqStack2);
                break;
            case 1://8进制转 2 10 16进制
                otc2BDH(&sqStack1,&sqStack2);
                break;
            case 2://10进制转 2 8 16进制
                dec2BOH(&sqStack1,&sqStack2);
                break;
            case 3://16进制转 2 8 10进制
                hex2BOD(&sqStack1,&sqStack2);
                break;
            case -1:
            default:
                break;
        }

        clearStack(&sqStack1);
        clearStack(&sqStack2);
    }while(d != -1);
}

//十进制转二进制、八进制、十六进制
void dec2BOH(SqStack *ptr, SqStack *ptr1)
{
    printf("十进制数:");
    stackTraverse(ptr,pfun,1);
    printf("\n");

    printf("二进制:");
    dec2Bin(ptr,ptr1);
    stackTraverse(ptr1,pfun,-1);
    printf("\n");

    clearStack(ptr1);

    printf("八进制:");
    dec2Otc(ptr,ptr1);
    stackTraverse(ptr1,pfun,-1);
    printf("\n");

    clearStack(ptr1);

    printf("十六进制:");
    dec2Hex(ptr,ptr1);
    stackTraverse(ptr1,pfun,-1);
    printf("\n");
}

//十六进制转二进制、八进制、十进制
void hex2BOD(SqStack *ptr, SqStack *ptr1)
{
    printf("十六进制数:");
    stackTraverse(ptr,pfun,1);
    printf("\n");

    printf("二进制:");
    hex2Bin(ptr,ptr1);
    stackTraverse(ptr1,pfun,1);
    printf("\n");

    clearStack(ptr1);

    printf("八进制:");
    hex2Otc(ptr,ptr1);
    stackTraverse(ptr1,pfun,-1);
    printf("\n");

    clearStack(ptr1);

    printf("十进制:");
    hex2Dec(ptr,ptr1);
    stackTraverse(ptr1,pfun,1);
    printf("\n");
}

//八进制转二进制、十进制、十六进制
void otc2BDH(SqStack *ptr, SqStack *ptr1)
{
    printf("八进制数:");
    stackTraverse(ptr,pfun,1);
    printf("\n");

    printf("二进制:");
    otc2Bin(ptr,ptr1);
    stackTraverse(ptr1,pfun,-1);
    printf("\n");

    clearStack(ptr1);

    printf("十进制:");
    otc2Dec(ptr,ptr1);
    stackTraverse(ptr1,pfun,1);
    printf("\n");

    clearStack(ptr1);

    printf("十六进制:");
    otc2Hex(ptr,ptr1);
    stackTraverse(ptr1,pfun,-1);
    printf("\n");
}

//二进制转八进制、十进制、十六进制
void bin2ODH(SqStack *ptr, SqStack *ptr1)
{
    printf("二进制数:");
    stackTraverse(ptr,pfun,1);
    printf("\n");

    printf("八进制:");
    bin2Otc(ptr,ptr1);
    stackTraverse(ptr1,pfun,1);
    printf("\n");

    clearStack(ptr1);

    printf("十进制:");
    bin2Dec(ptr,ptr1);
    stackTraverse(ptr1,pfun,1);
    printf("\n");

    clearStack(ptr1);

    printf("十六进制:");
    bin2Hex(ptr,ptr1);
    stackTraverse(ptr1,pfun,-1);
    printf("\n");
}



void input_value(SqStack *ptr)
{
    printf("请输入要转换的值,并以#结束输入.\n");
    printf("->");
    int c=10;//'\0'

    scanf("%c",&c);
    while(c != '#')
    {
        if(c=='A')
            c = 10;
        else if(c == 'B')
            c = 11;
        else if(c == 'C')
            c = 12;
        else if(c == 'D')
            c = 13;
        else if(c == 'E')
            c = 14;
        else if(c == 'F')
            c = 15;
        else
            c -= 48;//转换为整数
        push(ptr,&c);

        scanf("%c",&c);
    }
    getchar();

}


void test()
{

    SqStack sqStack;
    initStack(&sqStack,sizeof(int));
    int a=4,b=5,c=6;
    push(&sqStack, (void *) &a);
    push(&sqStack,(void *)&b);
    push(&sqStack,(void *)&c);

    pop(&sqStack,NULL);
    printf("Stack length now:%d\n",stackLength(&sqStack));
    stackTraverse(&sqStack,pfun,-1);
}

超大板栗

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C语言数据结构之利用栈机制写的进制转换器

将各个进制转换重新整理了以下，用栈的灵活机制写了一个进制转换器。图：代码：Stack.h#ifndef _STACK_H_#define _STACK_H_#include &lt;stdbool.h&gt;#define STACK_INIT_SIZE 100 //栈控件初始化大小#define STACK_INCREMENT 10 //栈控件增量typedef struct{ ...
复制链接

扫一扫

专栏目录