精华内容
下载资源
问答
  • 进制转换器项目要求:用户提供需要转换的数据和该数据的进制,以及要转换的进制,进制转换器提供给用户最终的正确转换的结果。 转换器实例 例如,用户提供了一个十进制数:10,要求将此数据以二进制形式转换,则...

    进制转换器项目要求:用户提供需要转换的数据和该数据的进制,以及要转换的进制,进制转换器提供给用户最终的正确转换的结果。

    转换器实例

    例如,用户提供了一个十进制数:10,要求将此数据以二进制形式转换,则通过进制转换器转换的最终结果应该:1010。

    提示:此进制转换器可以在 2-36 进制之间对数据进行任意转换。各进制中对应的数字如下表:

    设计思路

    当用户给定 2 - 36 进制中的任意一进制数时,最简单的方法是使用顺序存储结构进行存储,即使用字符串数组存储。

    转化时,最直接的思路就是先将该数转化为十进制数据,然后再由十进制转化成要求的进制数,最终的结果用栈结构存储(先进后出),这样最终显示给用户的是正常的数据。

    实现代码

    #include <stdio.h>
    #include <string.h>
    #include <math.h>
    int top = -1;  //top变量时刻表示栈顶元素所在位置 void push(char *a, char elem)
    { a[
    ++top] = elem; }
    void pop(char *a)
    {
    if (top == -1)
      {
    return ; }
    //输出时要按照正确的格式显示给用户 if (a[top] >= 10)
      { printf(
    "%c", a[top]+55); }
      else
      { printf("%d",a[top]); } top--; }
    //将各进制数转换成十进制数 int scaleFun(char *data, int system)
    {
    int k = (int)strlen(data) - 1; int system_10_data = 0; int i; for (i=k; i>=0; i--)
      {
    int temp; if (data[i]>=48 && data[i]<=57)
         { temp
    = data[i] - 48; }
         else
         { temp = data[i] - 55; } system_10_data += temp * pow(system, k-i); }
    return system_10_data; }
    int main()
    {
    char data[100]; printf("进制转换器,请输入原数据的进制(2-36):"); int system; scanf("%d", &system); getchar(); printf("请输入要转换的数据:"); scanf("%s", data); getchar(); int system_10_data = scaleFun(data, system); printf("请输入转换后的数据的进制:"); int newSystem; scanf("%d", &newSystem); getchar(); while (system_10_data/newSystem)
      { push(data, system_10_data
    % newSystem ); system_10_data /= newSystem; } push(data, system_10_data%newSystem); printf("转换后的结果为:\n"); while (top != -1)
      { pop(data); } }
    运行结果:
    
    进制转换器,请输入原数据的进制(2-36):10
    请输入要转换的数据:100
    请输入转换后的数据的进制:16
    转换后的结果为:
    64

     

    转载于:https://www.cnblogs.com/ciyeer/p/9031122.html

    展开全文
  • printf("进制转化,请输入原数据进制(2-36):"); int system; scanf("%d", &system); getchar(); printf("请输入要转化的数据:"); scanf("%s", data); getchar(); int system_10_data = scanfFun...

    代码:

    #include<stdio.h>
    #include<string.h>
    #include<math.h>
    int top = -1;//栈的初始化-代表空栈
    void push(char *a, char elem) {//入栈
    	a[++top] = elem;
    }
    void pop(char *a) {
    	if (top == -1) {
    		return;
    	}
    	if (a[top] >= 10) {
    		printf("%c", a[top] + 55);
    	}
    	else
    	{
    		printf("%d", a[top]);
    	}
    	top--;
    }
    //将各进制数转化成十进制数
    int scanfFun(char *data, int system) {
    	int k = (int)strlen(data) - 1;
    	int system_10_data = 0;
    	int i;
    	for (i = k; i > 0; i++) {
    		int temp;
    		if (data[i] > 48 && data[i] <= 57) {
    			temp = data[i] - 48;
    		}
    		else
    		{
    			temp = data[i] - 55;
    		}
    		system_10_data += temp * pow(system, k - i);
    	}
    	return system_10_data;
    }
    
    int main() {
    	char data[100];//定义了一个数组100长度
    	printf("进制转化器,请输入原数据的进制(2-36):");
    	int system;
    	scanf("%d", &system);
    	getchar();
    
    	printf("请输入要转化的数据:");
    	scanf("%s", data);
    	getchar();
    
    	int system_10_data = scanfFun(data, system);
    	printf("请输入转化后的数据进制:");
    	int newSystem;
    	scanf("%d", newSystem);
    	getchar();
    
    	while (system_10_data / newSystem) {
    		push(data, system_10_data%newSystem);
    		system_10_data /= newSystem;
    	}
    	push(data, system_10_data%newSystem);
    	printf("转换后的结果为:\n");
    	while (top != -1) {
    		pop(data);
    	}
    
    }
    

    结果:

    有点问题

    展开全文
  • 将各个进制转换重新整理了以下,用栈的灵活机制写了一个进制转换器。图:代码:Stack.h#ifndef _STACK_H_ #define _STACK_H_ #include &lt;stdbool.h&gt; #define STACK_INIT_SIZE 100 //栈控件初始化大小 ...

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

    图:


    代码: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);
    }






    展开全文
  • 进制转换器、平衡圆括号问题、海诺塔 参考文章: https://www.cnblogs.com/xiaohuochai/p/8174742.html#anchor5 http://shlpro.site/2017/03/28/《学习JavaScript数据结构与算法》读书笔记--栈/#disqus_thread 1....

    进制转换器、平衡圆括号问题、海诺塔

    参考文章:
    https://www.cnblogs.com/xiaohuochai/p/8174742.html#anchor5
    http://shlpro.site/2017/03/28/《学习JavaScript数据结构与算法》读书笔记--栈/#disqus_thread

    1.进制转换器

    原理: 将十进制数与要转换的进制基数相除,直至商为0,将余数从后向前排列即得到转换后的进制数

    Math.floor() 方法执行的是向下取整计算,它返回的是小于或等于函数参数,并且与之最接近的整数。可以理解为让除法的操作仅返回整数部分。

    // base: 基数; decNumber: 十进制数; rem: 余数
    var baseConverter = function(decNumber,base){
    
    	var remStack = new Stack(),
    		rem, //余数
    		baseString = '', //最后的*进制数
    		//讲数字转换为对应字母(十六进制是ABCDEF对应10 11 12 13 14 15)
    		digits = '0123456789ABCDEF'; 
    
    	while(decNumber>0){
    		//Math.floor(11.46)=Math.floor(11.68)=Math.floor(11.5)=11
    		//Math.floor(-11.46)=Math.floor(-11.68)=Math.floor(-11.5)=-12
    		rem = Math.floor(decNumber%base);
    		remStack.push(rem);
    		decNumber = Math.floor(decNumber/base);
    	}
    
    	while(!remStack.isEmpyy()){
    
    		baseString += digits[remStack.pop()];
    
    	}	
    
    	return baseString;
    
    }
    

    2.平衡圆括号问题

    原理: 从左向右查找时,第一个遇到的右括号,一定与它左侧最近的左括号匹配。同样,最后一个右括号,一定与第一个左括号相匹配。很像入栈出栈操作

    思路如下:
    1.巡检字符串,将括号分类,一类是左括号、一类是右括号。
    2.左括号看作是入栈信号,右括号是出栈信号。
    3.当出栈时,如果栈定没有与之匹配的元素,则宣告不匹配。
    4.当巡检完毕,如果得到空栈,则匹配,否则不匹配。

    const isBalanced = (str) => {
    
        const map = new Map([
            ["{", "}"],
            ["[", "]"],
            ["(", ")"]
        ])
    
        let stack = [];
    
        for(let i = 0 ; i < str.length; ++i){
            let node = str[i]
            
            if (map.has(node)){
                stack.push(node)
            }
            else if ([...map.values()].includes(node)){
                if (stack[stack.length - 1] !==
                                    [...map.entries()].filter(el=>el[1]===node).pop().shift()
                             ){
                    return false
                }
                stack.splice(stack.length-1, 1)
            }
        }
    
        return stack.length === 0
    
    }
    

    更多扩展及解释参考文章:
    https://mp.weixin.qq.com/s/va_23rCJhnr2LA9ILncNeg
    https://www.jinjingxuan.com/2018/11/06/面试-括号匹配/

    3.汉诺塔问题

    概念: 从左到右有A、B、C三根柱子,其中A柱子上面有从小叠到大的n个圆盘,现要求将A柱子上的圆盘移到C柱子上去,期间只有一个原则:一次只能移到一个盘子且大盘子不能在小盘子上面,求移动的步骤和移动的次数

    原理: 运用递归,可以将步骤抽象为:
    (1): 先将A柱的n-1个移动到B柱
    (2): 再将A柱的最后一个移动到C柱
    (3): 最后再将B柱的n-1个移动到C柱

    // index为需要花费多少次
    function hanoi (n,towerA,towerB,towerC) {
        index++;
        if (n == 1) {
            console.log(towerA + "to" + towerC);
        } else {
            hanoi(n - 1,towerA,towerC,towerB);
            console.log(towerA + "to" + towerC);
            hanoi(n - 1,towerB,towerA,towerC);
        }
    }
    var towerA = "A";
    var towerB = "B";
    var towerC = "C";
    var index = 0;
    hanoi(3,towerA,towerB,towerC);
    // 64次实现是太多了 我就以3为例子
    
    //输出结果
    AtoC
    AtoB
    CtoB
    AtoC
    BtoA
    BtoC
    AtoC
    

    参考文章:https://blog.csdn.net/zp1996323/article/details/48745485

    另一份参考代码:

    function towerOfHanoi(n, from, to, helper){
    
        if (n > 0){
            towerOfHanoi(n-1, from, helper, to);
            to.push(from.pop());
            console.log('-----');
            console.log('Source: ' + from.toString());
            console.log('Dest: ' + to.toString());
            console.log('Helper: ' + helper.toString());
            towerOfHanoi(n-1, helper, to, from);
        }
    }
    
    var source = new Stack();
    source.push(3);
    source.push(2);
    source.push(1);
    
    var dest = new Stack();
    var helper = new Stack();
    
    towerOfHanoi(source.size(), source, dest, helper);
    
    //输出结果
    -----
    Source: 3,2
    Dest: 1
    Helper: 
    -----
    Source: 3
    Dest: 2
    Helper: 1
    -----
    Source: 
    Dest: 2,1
    Helper: 3
    -----
    Source: 
    Dest: 3
    Helper: 2,1
    -----
    Source: 2
    Dest: 1
    Helper: 3
    -----
    Source: 
    Dest: 3,2
    Helper: 1
    -----
    Source: 
    Dest: 3,2,1
    Helper: 
    

    参考文章:https://www.cnblogs.com/xiaohuochai/p/8174742.html#anchor5

    再看另一份代码,了解递归里面执行栈:

    var a = [], b = [], c = [];
    var hanoi = function (disc, src, aux, dst) {   
        if (disc > 0) {
            console.log(disc);
            hanoi(disc - 1, src, dst, aux);
            console.log('移动盘子 ' + disc + ' 从 ' + src + ' 到 ' + dst + ' ;', '柱1: [' + a + ']', ' 柱2: [' + b + ']', ' 柱3: [' + c + ']');
            hanoi(disc - 1, aux, src, dst);
        };
    };
    var count = 3;
    for(var i = 1; i <= count; i++) {
            a.push(i);
        }
    console.log(a, b, c);
    hanoi(3, 'A', 'B', 'C');
    

    运行结果:

    在这里插入图片描述
    可以对递归的执行栈操作有了进一步了解。

    总结:把递归想象成一个栈的结构,之前函数没有执行完先推进栈里,在此基础上之后后面的函数;执行完出栈,继续执行之前的函数。

    参考文章(第二篇有图示):
    https://www.cnblogs.com/lswit/p/5217873.html
    https://shirley5li.me/2018/03/13/汉诺塔递归算法JS实现/

    https://www.zhihu.com/question/56832892
    https://wuzhiwei.net/ds_app_stack/

    参考文章:
    https://www.cnblogs.com/antineutrino/p/3334540.html
    https://www.cnblogs.com/vsky/p/5014657.html

    https://blog.csdn.net/zp1996323/article/details/48745485
    https://segmentfault.com/a/1190000006984865

    展开全文
  • C语言 算法与数据结构 用栈实现一个进制转换器 2-64互转 #include<stdio.h> #include<stdlib.h> #include<conio.h> #include<math.h> #include<windows.h> #define MAXSIZE 1000 ...
  • 1.很久没有更新博客了 这次想要记录分享一下在这段学习过程中实现的进制转换器 c语言代码 里面运用到了一些数据结构和递归的相关知识 也算是一个简单的综合运用吧 2.核心思想是将一切进制转换为10进制 再由十进制...
  • 二进制/八进制转换器

    2018-01-02 20:19:00
    进行数制转换这类运算最简单的方法就是使用栈的数据结构。 (1)在输入二进制数时,将每次输入的0/1压入栈A中保存。 (2)转换时,要将二进制的每三位转换成八进制的一位,先得到的是八进制的低位数,因此可以将八...
  • } root@book-virtual-machine:/mnt/hgfs/lua/C++# g++ -std=c++11 salman_0119.cpp -o salman_0119 root@book-virtual-machine:/mnt/hgfs/lua/C++# ./salman_0119 进制转换器,请输入原数据的进制(2-36):10 请...
  • 没有使用什么数据结构,直接使用qt自带的进制转换函数, 实时出结果,代码在后面的链接中,由于初学qt,好多不会,代码构造就有点乱 截图如下 代码 http://pan.baidu.com/s/1Ppwxo 转载于:...
  • 这个题目作为栈的开始,我们需要先了解一下栈,栈包括栈顶,栈底,栈顶指示,空栈,满栈,上溢,下溢等概念,栈是一种特殊的一种顺序表,栈的特性是后进先出,并且不能插队进栈出栈。栈的基本操作还是比较容易的,...
  • 栈是一种后入先出(LIFO)的数据结构,数据只能在栈顶添加或者删除,所以操作很快,容易实现。抽象数据类型定义 栈的JS实现 解决实际问题 抽象数据类型定义 属性及方法 作用 push() 入栈 pop() 出栈 peek() ...
  • - 数据解释, 已知 20 种数据类型 - 使用模板编辑数据结构 (例如: 修复分区表/引导扇区) - 连接和分割、以奇数偶数字节或字的方式合并、分解文件 - 分析和比较文件 - 搜索和替换功能尤其灵活 - 磁盘克隆 (可在 DOS ...
  • 易语言十六进制编辑源码,十六进制编辑,滚动条事件,取老矩形,取得表项矩形区域,插入数据,文本处理,转换到16进制,补位,编辑结束,进制_十六到十,SendMessage,取表项坐标信息,取表项结构信息,GetDC,CreatePen,...
  • 题目: 2/8进制转换器 编写程序,从终端输入一串0/1表示二进制数,以“#”结束,输出它的8进制表示形式。要求:采用栈来实现 #include <stdio.h> #include <stdlib.h> #define ERROR 0 #define OK 1 ...
  • 处理二进制文件或者从网络接收字节流时,字节流中的结构数据可能存在二进制有符号数。虽然开发者根据字节流协议可以先验的知道有符号数的字节序、字长、符号位等信息,但在使用Python进行类型转换时缺少将这些信息...
  • - 使用模板编辑数据结构 (例如: 修复分区表/引导扇区) - 连接和分割、以奇数偶数字节或字的方式合并、分解文件 - 分析和比较文件 - 搜索和替换功能尤其灵活 - 磁盘克隆 (可在 DOS 环境下使用 X-Ways Replica...
  • FCC项目:罗马数字转换器 一个将十进制数字转换为相应罗马数字的Javascript函数。 内容 介绍 作为FreeCodeCamp上JavaScript算法和数据结构课程的一部分而制作。 课程目标 将给定数字转换为罗马数字。 所有罗马数字...
  • 在学习完C语言初级阶段后,不知道大家有没有和我一样的想法,用C语言实现一个进制转换器,想着可能就几十行代码,但是真正上手操作后发现难度极大。首先考虑的就是正数负数原码补码问题,还有就是小数进制转换问题。...
  • 1. 队列 2. 栈 3. 二/八进制转换器 4.括号匹配问题
  • 数据结构栈(Stack)和队列(Queue)详解 本章讲解了两种特殊的线性表结构——栈和队列。...2. 数据结构实践项目之进制转换器 3. 括号匹配算法及C语言实现 4. 队列(Queue):“先进先出”的数据结构 5. ...
  • 前言处理二进制文件或者从网络接收字节流时,字节流中的结构数据可能存在二进制有符号数。虽然开发者根据字节流协议可以先验的知道有符号数的字节序、字长、符号位等信息,但在使用Python进行类型转换时缺少将...
  • 数据结构讨论课三:二叉树的应用——哈夫曼树的编/译码的设计和实现【皮皮蕾】 题目要求 输出效果 源码 作者自述 题目要求 在数据通信系统中,电文传送是经常遇到的问题,传送电文时需要将字符转换成...
  • 摘要:AD9224模数转换器的最高采样频率为40MHz,数据精度为12位。内部采用闪烁式AD及多级流水线式结构,因而不失码,使用方便、准确度高。文章介绍了高速模数转换器AD9224的性能、结构及几种典型应用电路。  ...
  • 用TypeScript编写的数据结构和算法 ...十进制到二进制的转换器进制转换为任何基数 使用循环队列的热土豆 工具 打字稿 ESLint 笑话 斯特瑞克·穆特 编辑器配置 沙哑 皮棉上演 特拉维斯 工作服 骗子
  • D/A转换器(华师)

    万次阅读 2012-08-19 22:20:55
    9.2 D/A转换器 9.2.1 D/A转换器的基本工作原理  D/A转换器是将输入的二进制数字... D/A转换器的一般结构如图9.1所示, 图中数据锁存器用来暂时存放输入的数字信号。n位寄存器的并行输出分别控制n个模拟开关
  • 栈的应用十分广泛,例如之前提到的...栈是一种后进先出的数据结构,当需要逆序操作时,我们就可以使用栈实现十进制与其他进制之间的转换,因为无法限制十进制数的大小,所以这里使用链栈。 这里只是实现了十进...
  • 数据结构,算法,动态程序,递归和一点编码的乐趣! 介绍 欢迎您使用代码。 如果发现任何错误,请提出问题。 我会尽快修复。 每当我看到任何有趣的编码难题时,我都会继续发布新代码。 包含的内容: 拼图编码乐趣: ...
  • String 与 byte[]之间的转换 编码:String --> byte[]:调用String的getBytes() 解码:byte[] --> String:调用String的构造 编码:字符串 -->字节 (看得懂 —>看不懂的二进制数据) 解码:编码的逆过程...
  • 与大多数现有解决方案不同,我们需要正确处理这些结构,从而避免将完全有效的数据结构转换为会导致远程系统内存泄漏的数据结构。 为了实现跨语言兼容性,其他解码实现可以很容易地忽略弱引用。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 556
精华内容 222
关键字:

数据结构进制转换器

数据结构 订阅