精华内容
下载资源
问答
  • 数据结构中,利用栈实现进制转换
  • 利用栈实现进制转换

    2021-11-02 16:33:59
    一、的概念 是一种基本的数据结构,分为顺序和链式两种。...二、基本操作的代码实现 1.宏定义 typedef int Elementype; typedef struct Node *PNode; typedef struct Stack *PStack; typede

    一、栈的概念

    栈是一种基本的数据结构,分为顺序栈和链式栈两种。栈的基本特点是先入栈的元素后离栈。在理解这一特点时,我们可以把他当做一个箱子,先放入的东西会到最下面,例如下图:将1、2、3、4依次保存入栈,最后放入栈中的元素会保存在栈的顶部。也就是说,在将元素读出栈时,与入栈的顺会是正好相反的。

    在这里插入图片描述

    二、栈基本操作的代码实现

    1.宏定义

    typedef int Elementype;
    typedef struct Node *PNode;
    typedef struct Stack *PStack;
    typedef struct Node Node;
    typedef struct Stack Stack;
    

    2.结构体的创建

    typedef struct Node {
        Elementype data;
        struct Node *next;
    } Node, *PNode;
    
    typedef struct Stack {
        PNode top;
        PNode bottom;
    } Stack, *PStack;
    

    3.栈中节点与栈的创建

    PNode Create_Node() {
        PNode p = (PNode) malloc(sizeof(Node));
        if (!p) {
            printf("节点未创建成功");
            exit(-1);
        }
        p->data = 0;
        p->next = NULL;
        return p;
    }
    PStack Create_Stack() {
        PStack s;
        s = (PStack) malloc(sizeof(Stack));
        if (!s) {
            printf("栈未创建成功");
            exit(-1);
        } else {
            s->top = s->bottom;
            s->top = NULL;
            return s;
        }
    }
    

    4.入栈以及遍历操作

    void Push_Stack(PStack S, int i) {
        PNode p = Create_Node();
        if (!p) {
            printf("节点未创建成功");
        }
        p->data = i;
        p->next = S->top;
        S->top = p;
    }
    
    void Traverse_Stack(PStack S) {
        PNode p;
        p = S->top;
        while (p != S->bottom) {
            printf("%d", p->data);
            p = p->next;
        }
        printf("\n");
    }
    

    三、实现进制转换

    我们知道在进行进制转换时,用原数除以要转换的进制,直到余数为零。最后将所得余数倒序排列,即可得到转换后的数字。利用这一特点,我们可以将每次的余数保存进栈中,最后遍历得到栈中元素,正好是转化后数字的正确顺序。下面是代码实现(在上面栈的各项操作实现的情况下)。

    int main() {
        PStack S = Create_Stack();
        int n;
        printf("请输入需要转化的数字");
        scanf("%d", &n);
        while (n) {
            Push_Stack(S, n % 2);
            n = n / 2;
        }
        Traverse_Stack(S);
    }
    

    运行结果:

    在这里插入图片描述
    欢迎大家评论区讨论。

    展开全文
  • 栈实现进制转换

    2017-10-04 17:03:44
    该资源利用栈的知识实现进制转换,包含栈的建立,清空,压栈,出栈等基本操作,以及辗转相除法求余数
  • 利用栈实现进制转换问题

    千次阅读 2019-05-05 13:49:40
    进制转换问题 建立顺序或链栈,编写程序实现十进制数到二进制数的转换。 输入 输入只有一行,就是十进制整数。 输出 转换后的二进制数。 样例输入 10 样例输出 1010 十进制怎么转为二进制?十进制转二...

    进制转换问题

    建立顺序栈或链栈,编写程序实现十进制数到二进制数的转换。

    输入

    输入只有一行,就是十进制整数。

    输出

    转换后的二进制数。

    样例输入

    10

    样例输出

    1010

    十进制怎么转为二进制?十进制转二进制怎么转?
    十进制整数转换为二进制整数采用"除2取余,逆序排列"法。具体做法是:用2整除十进制整数,可以得到一个商和余数;再用2去除商,又会得到一个商和余数,如此进行,直到商为小于1时为止,然后把先得到的余数作为二进制数的低位有效位,后得到的余数作为二进制数的高位有效位,依次排列起来

    利用栈的后进先出性质写一个10到2进制转换的小程序,实现顺序栈,代码如下:

    #include<bits/stdc++.h>
    typedef struct Stack
    {
    	int data[100];
    	int top;
    }SqStack;   
    //建立顺序栈
    
    void Init(SqStack *&s)
    {
    	s=(SqStack *)malloc(sizeof(SqStack));
    	s->top=-1;
    }      
    //栈的初始化
    
    bool En(SqStack *&s,int e)
    {
    	if(s->top==99)
    	return false;
    	s->top++;
    	s->data[s->top]=e;
    	return true;
    }      
    //进栈
    
    bool Pop(SqStack *&s)
    {
    	if(s->top==-1)
    	return false;
    	s->top--;
    	return true;
    }     
    //出栈
     
    int main()
    {
    	printf("十进制到二进制转换程序\n*******************\n"); 
    	SqStack *s;
    	Init(s);
    	int n,m;
    	printf("请输入一个十进制的整数\n");
    	scanf("%d",&n);
    	m=n;
    	while(m!=0)
    	{
    		int e=m%2;
    		En(s,e);
    		m/=2;
    	}
    	printf("其转化为二进制的数为");
    	while(s->top!=-1)
    	{
    		printf("%d",s->data[s->top]);
    		Pop(s);
    	}
    	return 0;
    }
    
    

    在这里插入图片描述

    展开全文
  • 数据结构学习笔记:利用栈实现进制转换 一、除基倒取余法示意图 二、编写十进制转换成二进制Python程序 1、源代码 2、运行结果 其实Python提供了一个bin()函数,可将十进制整数转换成二进制字符串: ...

    数据结构学习笔记:利用栈实现进制转换

    一、除基倒取余法示意图

    二、编写十进制转换成二进制Python程序

    1、源代码

    2、运行结果

    其实Python提供了一

    展开全文
  • 栈--利用栈实现进制转换

    万次阅读 多人点赞 2018-03-30 15:32:58
    利用栈实现进制转换 一、二进制转十进制 利用栈的数据结构特点,将二进制转换为十进制数。 二进制数是计算机数据的存储形式,它是由一串0和1组成的,每个二进制数转换成相应的十进制数方法如下: (XnXn-1……...

    利用栈实现进制转换

    一、二进制转十进制

    利用栈的数据结构特点,将二进制转换为十进制数。

    二进制数是计算机数据的存储形式,它是由一串0和1组成的,每个二进制数转换成相应的十进制数方法如下:
    (XnXn-1……X3X2X1)2 = X1*2^0+X2*2^1+…+Xn*2^(n-1)

    一个二进制数要转换为相应的十进制数,就是从最低位起用每一位去乘以对应位的积,也就是说用第n位去乘以2^(n-1),然后全部加起来。

    二进制转十进制.png

    由于栈具有后进先出的特性,
    例如输入11001001这样的二进制数,
    如图:

    栈中的二进制数.png

    代码实现:

    #include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    
    #define STACK_INIT_SIZE 20   
    #define STACKINCREMENT  10
    
    typedef char ElemType;
    typedef struct
    {
        ElemType *base;
        ElemType *top;
        int stackSize;  
    }sqStack;
    
    void InitStack(sqStack *s)
    {
        s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
        if( !s->base )
        {
            exit(0);
        }
    
        s->top = s->base;
        s->stackSize = STACK_INIT_SIZE;
    }
    
    void Push(sqStack *s, ElemType e)
    {
        if( s->top - s->base >= s->stackSize )
        {
            s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
            if( !s->base )
            {
                exit(0);
            }
        }
    
        *(s->top) = e;
        s->top++;
    }
    
    void Pop(sqStack *s, ElemType *e)
    {
        if( s->top == s->base )
        {
            return;
        }
        *e = *--(s->top);
    }
    
    int StackLen(sqStack s)
    {
        return (s.top - s.base);
    }
    
    int main()
    {
        ElemType c;
        sqStack s;
        int len, i, sum = 0;
    
        InitStack(&s);
    
        printf("请输入二进制数,输入#符号表示结束!\n");
        scanf("%c", &c);
        while( c != '#' )
        {
            Push(&s, c);
            scanf("%c", &c);
        }
    
        getchar();  // 把'\n'(回车)从缓冲区去掉
    
        len = StackLen(s);
        printf("栈的当前容量是: %d\n", len);
    
        for( i=0; i < len; i++ )
        {
            Pop(&s, &c);
            sum = sum + (c-48) * pow(2, i);
        }
    
        printf("转化为十进制数是: %d\n", sum);
    
        return 0;
    }
    

    二、二进制转八进制

    二进制是计算机唯一认识的,十进制是人们通常使用的。

    观察二进制跟十六进制的对应关系:

    二进制与十六进制的对应关系.png

    可见一个字节(8bit)刚好用两个十六进制数可以表示完整,也大大的节省了显示空间。

    八进制:因为早期的计算机系统都是三的倍数,所以用八进制比较方便。

    在进行二进制到八进制的转换时,要将二进制数的每三位转换成一个八进制数来表示,然后按顺序输出即可。

    1.png

    2.png

    3.png

    代码实现:

    /**  二进制/八进制转换器   **/
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    
    #define STACK_INIT_SIZE 20
    #define STACKINCREMENT  10
    
    typedef char ElemType;
    typedef struct
    {
        ElemType *base;
        ElemType *top;
        int stackSize;
    }sqStack;
    
    // 函数功能:初始化栈
    // 参数*s:栈的地址
    void InitStack(sqStack *s)
    {
        s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
        if( !s->base )
        {
            exit(0);
        }
    
        s->top = s->base;
        s->stackSize = STACK_INIT_SIZE;
    }
    
    // 函数功能:入栈操作
    // 参数*s:栈的地址
    // 参数e:待压入栈的元素
    void Push(sqStack *s, ElemType e)
    {
        if( s->top - s->base >= s->stackSize )
        {
            s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
            if( !s->base )
            {
                exit(0);
            }
    
            s->top = s->base + s->stackSize;
            s->stackSize = s->stackSize + STACKINCREMENT;
        }
    
        *(s->top) = e;
        s->top++;
    }
    
    // 函数功能:弹栈操作
    // 参数*s:栈的地址
    // 参数e:存放从栈里弹出的数据
    void Pop(sqStack *s, ElemType *e)
    {
        if( s->top == s->base )
        {
            return;
        }
        *e = *--(s->top);
    }
    
    // 函数功能:计算栈s的当前长度
    // 参数s:栈
    int StackLen(sqStack s)
    {
        return (s.top - s.base);
    }
    
    int main()
    {
        ElemType c;
        sqStack s1;
        sqStack s2;
        int len, i, j, sum = 0;
    
        InitStack(&s1); // 初始化栈s1,用来存放二进制输入
    
        printf("请输入二进制数,输入‘#’号表示结束!\n\n");
        scanf("%c", &c);
        while( c != '#' )
        {
            if( c=='0' || c=='1' )  // 检查输入是否二进制
                Push(&s1, c);
            scanf("%c", &c);
        }
        getchar();      // 把'\n'从缓冲区去掉
        len = StackLen(s1);
    
        InitStack(&s2); // 初始化栈s2,用来存放转换的八进制
    
        for( i=0; i < len; i+=3 )
        {
            for( j=0; j < 3; j++ )
            {
                Pop( &s1, &c ); // 取出栈顶元素
                sum = sum + (c-48) * pow(2, j);
    
                if( s1.base == s1.top )
                {
                    break;
                }
            }
    
            Push( &s2, sum+48 );
            sum = 0;
        }
    
        printf("\n转化为八进制数是: ");
        while( s2.base != s2.top )
        {
            Pop( &s2, &c );
            printf("%c", c);
        }
        printf("(O)\n");
    
        return 0;
    }
    

    三、二进制转十六进制

    代码实现:

    /** 二进制/十六进制转换器  **/
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    
    #define STACK_INIT_SIZE 20
    #define STACKINCREMENT  10
    
    typedef char ElemType;
    typedef struct
    {
        ElemType *base;
        ElemType *top;
        int stackSize;
    }sqStack;
    
    // 函数功能:初始化栈
    // 参数*s:栈的地址
    void InitStack(sqStack *s)
    {
        s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
        if( !s->base )
        {
            exit(0);
        }
    
        s->top = s->base;
        s->stackSize = STACK_INIT_SIZE;
    }
    
    // 函数功能:入栈操作
    // 参数*s:栈的地址
    // 参数e:待压入栈的元素
    void Push(sqStack *s, ElemType e)
    {
        if( s->top - s->base >= s->stackSize )
        {
            s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
            if( !s->base )
            {
                exit(0);
            }
    
            s->top = s->base + s->stackSize;
            s->stackSize = s->stackSize + STACKINCREMENT;
        }
    
        *(s->top) = e;
        s->top++;
    }
    
    // 函数功能:弹栈操作
    // 参数*s:栈的地址
    // 参数e:存放从栈里弹出的数据
    void Pop(sqStack *s, ElemType *e)
    {
        if( s->top == s->base )
        {
            return;
        }
        *e = *--(s->top);
    }
    
    // 函数功能:计算栈s的当前长度
    // 参数s:栈
    int StackLen(sqStack s)
    {
        return (s.top - s.base);
    }
    
    int main()
    {
        ElemType c;
        sqStack s1;
        sqStack s2;
        int len, i, j, sum = 0;
    
        InitStack(&s1); // 初始化栈s1,用来存放二进制输入
    
        printf("请输入二进制数,输入‘#’号表示结束!\n\n");
        scanf("%c", &c);
        while( c != '#' )
        {
            if( c=='0' || c=='1' )  // 检查输入是否二进制
                Push(&s1, c);
            scanf("%c", &c);
        }
        getchar();      // 把'\n'从缓冲区去掉
        len = StackLen(s1);
    
        InitStack(&s2); // 初始化栈s2,用来存放转换的八进制
    
        for( i=0; i < len; i+=4 )
        {
            for( j=0; j < 4; j++ )
            {
                Pop( &s1, &c ); // 取出栈顶元素
                sum = sum + (c-48) * pow(2, j);
    
                if( s1.base == s1.top )
                {
                    break;
                }
            }
    
            switch( sum )
            {
                case 10: sum = 'A'; break;
                case 11: sum = 'B'; break;
                case 12: sum = 'C'; break;
                case 13: sum = 'D'; break;
                case 14: sum = 'E'; break;
                case 15: sum = 'F'; break;
                default: sum += 48;
            }
    
            Push( &s2, sum );
            sum = 0;
        }
    
        printf("\n转化为十六进制数是: ");
        while( s2.base != s2.top )
        {
            Pop( &s2, &c );
            printf("%c", c);
        }
        printf("(H)\n");
    
        return 0;
    }
    
    展开全文
  • #include #include //#include //#pragma GCC optimize(2) ... cout 请输入将要转为K进制的数N以及K" ;  int num,k;  cin >> num >> k;  conversion(num,k);  return 0; }
  • 进制转换栈实现

    2017-07-08 15:12:04
    利用栈实现进制转换,支持16进制以下进制(2-10、16),更改相应的参数还可扩展其他进制转换,还可以通过更改宏定义来扩宽进制转换的数据范围。用户通过输入想要转换的进制和待转换的数字
  • 作业code3 十进制转换二进制(代码已经给大家,详情参考“PPT-Jk17数据...顺序栈实现进制转换 #include &lt;stdio.h&gt; #include &lt;malloc.h&gt; #include &lt;iostream&gt; using n...
  • 主要介绍了C语言用栈实现进制转换为二进制的方法,结合实例形式分析了C语言的定义及进制转换使用技巧,需要的朋友可以参考下
  • 将十进制转换为八进制 #include<iostream> #include<stack> using namespace std; int main(){ stack<int> p; int x; cout<<"请输入一个十进制的数字:"; cin>>x; while(x){ p...
  • 根据的特性,FILO,很方便的就可以实现进制转换。  关于的一系列操作,在此不再做任何赘述。我这里只是介绍一下压栈(psuhStack),和弹(popStack):  1.压栈:就是把元素一个一个的压入栈中。例如:八进制的...
  • 栈实现进制转换

    2013-10-29 16:44:21
    C++语言 利用栈操作实现进制转换成任意进制。
  • C语言栈实现进制转换

    2021-01-31 19:54:05
    例如讲10进制转换为2进制计算思路为: 利用循环将每一个余数都压入栈中,再遍历出栈 转换代码: /* 进制转换 */ scStack *sysConvert(int num,int system,scStack *sys){ int q = num / system;//商 int r = num...
  • #include using namespace std; #define InitSize 20 typedef int QElemType; typedef struct { QElemType *data; int top,maxsize; }LinkQueue;...void QueueInit(LinkQueue&...void Push(LinkQu
  • 用C语言栈实现进制转换

    千次阅读 2020-10-19 11:36:11
    #include<stdio.h> #include<stdlib.h> #include<...typedef struct //定义的结构体 { int data[MAXSIZE]; int top; }Se,*Pe; Pe begin(); //的初始化 void ru(Pe S,int x); //入栈函数 P
  • C语言-顺序栈实现进制转换为二进制-八进制-十六进制
  • 利用栈进行进制转换(c++)

    千次阅读 2020-10-03 11:25:20
    用c++利用栈存储结构将十进制转换为八进制和十六进制 #include <iostream> using namespace std; /* run this program using the console pauser or add your own getch, system("pause") or input loop */ #...
  • 进制转换函数 //进制转换 void conversion() { int n, N; LinkStack S; S =InitStack(S); printf("请输入想要转换的数字和进制:"); scanf("%d%d", &n, &N); while(n) { S = Push(S, n%N); n =...
  • 使用栈实现进制转换

    千次阅读 2018-04-13 11:52:43
    进制转换原理 上图是十进制150转换为二进制的实例,实现方式是将150除以2取余,将余数记下,然后商继续除以2取余,重复该操作,直到商为0为止。 然后将得到的所有余数倒着连起来,就是二进制的值。 十进制转为...
  • java利用栈进行进制转换

    千次阅读 2018-10-25 17:01:27
    (Stack)是一种特殊的线性表,其插入和删除操作只允许在线性表的一端进行。通常称允许插入、删除操作的这一端为栈顶(Top),不允许操作的一端称为底(Bottom)。当表中没有元素时称为空栈。 假设S=(a0,a1,a2,a3...
  • 栈实现进制转换

    千次阅读 2020-06-06 16:16:03
    将一个十进制整数N转换成八进制,把N与8求余得到八进制数的各位依次进栈,计算完毕后将中的八进制依次出栈输出,输出的结果就是待求八进制数 2.算法设计步骤 初始化一个空栈 把N与8求余得到的八进制数压入栈中 ...
  • 顺序栈实现进制转换

    2020-09-20 15:57:42
    # 使用顺序栈实现进制转换成其他进制操作 class sstack(): def __init__(self): # 初始化一个空栈 self.slist= [] def is_empty(self):# 判断是否为空 if self.slist == []: return 1 else: return 0 ...
  • 利用栈进行进制转换

    2017-11-08 17:30:49
    用递归和进行简单进制转换。 #include<stdio.h> #include<stdlib.h> #define N 10000 struct stack { int top; //栈顶 int data [N]; }; struct stack selfstack = { -1,{0} }; //的初始化 ...
  • C++用顺序栈实现进制转换

    千次阅读 多人点赞 2019-04-20 19:14:16
    C++语言,用顺序栈实现进制向任意进制转换 #include<iostream> #include<stdlib.h> #include<fstream> using namespace std; typedef int ElemType; struct Stack{ ElemType *...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 49,230
精华内容 19,692
关键字:

利用栈实现进制转换