精华内容
下载资源
问答
  • 十进制转十六进制.cpp

    2020-12-05 15:59:16
    十进制转十六进制.cpp
  • C语言-顺序实现十进制转换为二进制-八进制-十六进制
  • 这篇文章主要介绍了使用Python内置函数:bin()、oct()、int()、hex()可实现进制转换的一些用法,需要的朋友可以参考下 使用Python内置函数:bin()、oct()、int()、hex()可实现进制转换。 先看Python官方文档中对这几...
  • c语言实现十进制转换为二进制,八进制和十六进制 写一个程序,将输入的十进制数据M 转换为八进制数据M8,将其调试通过.在此基础上修改程序,实现十进制数据M 向N 进制(2或8或16)的转换. #include<stdio.h> #...

    c语言栈实现十进制转换为二进制,八进制和十六进制

    写一个程序,将输入的十进制数据M 转换为八进制数据M8,将其调试通过.在此基础上修改程序,实现十进制数据M 向N 进制(2或8或16)的转换.

    #include<stdio.h>
    #include<stdlib.h>
    #define INIT_SIZE 100
    #define N 80
    
    
    typedef struct stack{
    	int *top,*base;
    	int size; 
    }stack;
    
    /********初始化构建一个空栈*********/ 
    void initStack(stack &s){
    	s.base=(int*)malloc(sizeof(int)*INIT_SIZE);//分配储存空间 
    	if(!s.base)//如果分配失败则退出 
    		exit(0);
    	s.size=INIT_SIZE;
    	s.top=s.base;//注意,若写成s.base=s.top,则会导致栈初始化失败 
    }
    
    
    
    
    //push函数将元素压入栈
    void push(stack &s,int m){
    	
    	int *p=NULL;
    	if(!s.base)
    		exit(0);
    	if(s.size<=s.top-s.base){//若储存空间不够 ,则重新申请 
    		p=(int*)realloc(s.base,sizeof(int)*(INIT_SIZE+N));
    		if(!p){
    			printf("内存再次分配失败!");
    			exit(0);
    		}
    		s.base=p;
    		s.top=s.base+N;
    		s.size+=N;
    		
    	}
    	*s.top=m; //将新元素压进栈顶;
    	s.top++; //栈顶指针向上移动1个单位 
    }
    
    /********出栈函数*********/ 
    int pop(stack &s){
    	int m;
    	
    	s.top--;//栈顶指针指向最上面的元素 
    	m=*s.top;//将栈顶元素赋给m 
    	return m;
    }
    
    /********计算相应的进制并输出*********/  
    void calcu(stack &s,int n,int r){
    	int temp,m;
    	while(n){
    		temp=n%r;
    		n/=r;
    		push(s,temp);
    	}
    	while(s.top!=s.base){//若栈中还有元素,则进入循环,执行输出操作 
    		m=pop(s);
    		if(r==16){//若为16进制 
    			if(m==10)
    				printf("A");
    			else if(m==11)
    				printf("B");
    			else if(m==12)
    				printf("C");
    			else if(m==13)
    				printf("D");
    			else if(m==14)
    				printf("E");
    			else if(m==15)
    				printf("F");
    			else printf("%d",m);						
    		}
    		else
    			printf("%d",m);//2进制和8进制 
    		
    	}
    } 
    
    
    int main(){
    	int i,n;
    	stack s;
    	initStack(s);
    	printf("请输入一个十进制的数字:");
    	scanf("%d",&n);
    	if(n<0){ 
    		printf("输入的数字有误!");
    		exit(0);
    	}
    	printf("对应的二进制的是:");
    	calcu(s,n,2);
    	printf("\n对应的八进制的是:");
    	calcu(s,n,8);
    	printf("\n对应的十六进制的是:");
    	calcu(s,n,16);	
    	return 0;	
    }
    

    注意:此代码具有局限性,十位以内的运算正确,超出十位则会发生错误
    在这里插入图片描述在这里插入图片描述

    展开全文
  • 十六进制的计数方法是满16进1,所以十进制数16在十六进制中是10,而十进制的17在十六进制中是11,以此类推,十进制的30在十六进制中是1E。  给出一个非负整数,将它表示成十六进制的形式。 输入格式  输入...

    问题描述

      十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F共16个符号,分别表示十进制数的0至15。十六进制的计数方法是满16进1,所以十进制数16在十六进制中是10,而十进制的17在十六进制中是11,以此类推,十进制的30在十六进制中是1E。
      给出一个非负整数,将它表示成十六进制的形式。

    输入格式

      输入包含一个非负整数a,表示要转换的数。0<=a<=2147483647

    输出格式

      输出这个整数的16进制表示

    样例输入

    30

    样例输出

    1E

     

    主要是想联系一下栈方法,刚开始一直90分,最后发现忘了考虑输入为0的时候了,这是个小坑要注意。

    方法一:栈方法实现

    
    #include <iostream>
    #include <bits/stdc++.h>
    using namespace std;
    
    typedef int SElemType;
    typedef int Status;
    
    #define TRUE        1
    #define FALSE       0
    #define OK          1
    #define ERROR       0
    #define INFEASIBLE -1
    //#define OVERFLOW   -2
    
    #define STACK_INIT_SIZE  100
    #define STACKINCREMENT   10
    typedef struct
    {
        int *base;
        int *top;
        int stacksize;
    } SqStack;
    
    
    Status InitStack(SqStack &S);
    
    Status Push(SqStack &S,SElemType e);
    
    Status Pop(SqStack &S,SElemType &e);
    
    bool JudgeEmpty(SqStack &S);
    
    
    
    int main()
    {
        SqStack S;
        InitStack(S);
        int n,e;
        cin>>n;
        if(n == 0)
            cout<<n;
        else
        {
            while(n)
            {
                Push(S,n%16);
                n/=16;
            }
            while(!JudgeEmpty(S))
            {
                Pop(S,e);
                switch(e)
                {
                case 10:
                    cout<<"A";
                    break;
                case 11:
                    cout<<"B";
                    break;
                case 12:
                    cout<<"C";
                    break;
                case 13:
                    cout<<"D";
                    break;
                case 14:
                    cout<<"E";
                    break;
                case 15:
                    cout<<"F";
                    break;
                default:
                    cout<<e;
                    break;
                }
            }
        }
        cout<<endl;
    }
    
    Status InitStack(SqStack &S)
    {
        S.base = (SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
        if(!S.base)
            exit(OVERFLOW);
        S.top = S.base;
        S.stacksize = STACK_INIT_SIZE;
        return OK;
    }
    
    Status Push(SqStack &S,SElemType e)
    {
        if(S.top - S.base >= S.stacksize)
        {
            S.base = (SElemType*)realloc(S.base,(S.stacksize + STACKINCREMENT)*sizeof(SElemType));
            if(!S.base)
                exit(OVERFLOW);
            S.top = S.base + S.stacksize;
            S.stacksize += STACKINCREMENT;
        }
        *S.top++ = e;
        return OK;
    }
    
    Status Pop(SqStack &S,SElemType &e)
    {
        if(S.top == S.base)
            return ERROR;
        e = *--S.top;
        return OK;
    }
    
    bool JudgeEmpty(SqStack &S)
    {
        if(S.base == S.top)
            return true;
        else
            return false;
    }
    

    方法2:用数组解决

    
    #include <iostream>
    #include <string>
    using namespace std;
    
    int a[10000000];
    int main()
    {
        int n,k=0;
        cin >> n;
        if(!n)
            cout<<n;
        else
        {
            while(n)
            {
                a[k++] = n%16;
                n/=16;
            }
            for(int i = k-1;i>=0;i--)//类似于模拟栈(反着遍历)
            {
                switch(a[i])
                {
                    case 10:cout<<"A";break;
                    case 11:cout<<"B";break;
                    case 12:cout<<"C";break;
                    case 13:cout<<"D";break;
                    case 14:cout<<"E";break;
                    case 15:cout<<"F";break;
                    default:cout<<a[i];break;
                }
            }
            cout<<endl;
        }
    }
    

    总结:看似数组的方法更简单,其实不然。栈的引入简化了程序设计的问题,划分了不同的关注层次,减少了思考的范围。而用数组则掩盖了问题的本质,还要非常仔细的注意数组下标增减等一系列的细节问题

    展开全文
  • 十进制十六进制的转换 数据结构c 入栈,出栈,判断是否为空
  • 实现二进制转十六进制 相对于二进制八进制而言,二进制转十六进制需要多判断一下sum求出来的数是否大于10,如果大于10就成A,以此类推 #include <iostream> #include <cstdlib> #include <...

    栈实现二进制转十六进制

    相对于二进制转八进制而言,二进制转十六进制需要多判断一下sum求出来的数是否大于10,如果大于10就转成A,以此类推

    #include <iostream>
    #include <cstdlib>
    #include <cmath>
    using namespace std;
    
    typedef char ElemType;
    typedef struct{
    	ElemType *top;
    	ElemType *base;
    	int StackSize;
    }sqStack;
    
    const int Stack_Init_Size = 20;
    const int StackIncrement = 10;
    void Push(sqStack *s,ElemType e);
    void Pop(sqStack *s,ElemType *e);
    bool InitStack(sqStack *s);
    int LenStack(sqStack s);
    
    int main()
    {
    	sqStack s,h;
    	InitStack(&s);
    	InitStack(&h);
    	ElemType c;
    	cout << "Enter a Bin number(# to stop): ";
    	while(cin >> c && '#' != c){
    		if('0' != c && '1'!= c)
    		{
    			cout << "Enter Bin Error.\n";
    			return 0;
    		}
    		Push(&s,c);
    	}
    	int len = LenStack(s);
    	int sum;
    	for(int i=0; i<len; i+=4){
    		sum = 0;
    		if(LenStack(s)>=4)
    		{
    			for(int j=0; j<=3; j++){
    				Pop(&s,&c);
    				sum = sum + (c-48)*pow(2,j);
    			}
    		}
    		else
    		{
    			for(int j=0; (s.top-s.base) != 0; j++){
    				Pop(&s,&c);
    				sum = sum + (c-48)*pow(2,j);
    			}
    		}
    		if(sum<10)
    			Push(&h,sum+48);
    		if(sum>=10)
    			Push(&h,sum+55);
    	}
    	int len_h = LenStack(h);
    	cout << "The HEX number is: ";
    	for(int i=0; i<len_h; i++){
    		Pop(&h,&c);
    		cout << c;
    	}
    	cout << endl;
    	return 0;
    }
    
    bool InitStack(sqStack *s)
    {
    	s->base = (ElemType *)malloc(Stack_Init_Size*sizeof(ElemType));
    	if(!s->base)
    	{
    		cout << "Initital Error.\n";
    		return false;
    	}
    	s->top = s->base;
    	s->StackSize = Stack_Init_Size;
    	return true;
    }
    
    void Push(sqStack *s,ElemType e)
    {
    	if(s->top - s->base >= s->StackSize)
    	{
    		s->base = (ElemType *)realloc(s->base,(StackIncrement+s->StackSize)*sizeof(ElemType));
    		if(!s->base)
    		{
    			cout << "Increment Error.\n";
    			exit(EXIT_FAILURE);
    		}
    	}
    	*(s->top) = e;
    	s->top++;
    }
    
    int LenStack(sqStack s)
    {
    	if(s.top - s.base == 0)
    	{
    		cout << "It's empty stack.\n";
    		return 0;
    	}
    	return s.top - s.base;
    }
    
    void Pop(sqStack *s,ElemType *e)
    {
    	if(s->top - s->base == 0)
    	{
    		cout << "It's empty.\n";
    		return;
    	}
    	*e = *--(s->top);
    }
    

    Notes:需要注意的地方和转八进制相同,需要的可以看一下二进制转八进制
    https://blog.csdn.net/weixin_45677702/article/details/107991781

    展开全文
  • 判断括号配对与十进制转十六进制判断括号配对与十进制转十六进制
  • 1、二进制转进制: /*二进制转进制*/ #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;stdlib.h&amp;gt; #include&amp;lt;math.h&amp;gt; #define MAXSIZE 20 #define ...

    1、二进制转八进制:

    /*二进制转八进制*/ 
    
    #include<stdio.h>
    #include<stdlib.h>
    #include<math.h>
    
    #define  MAXSIZE  20
    #define  ERROR    0
    #define  OK       1
    
    typedef int  Status;
    typedef char Elemtype;
    
    typedef struct{         //栈的静态分配存储结构 
    	Elemtype elem[MAXSIZE];
    	int top;
    }SqStack;
    
    void InitStack(SqStack *S)
    {
    	S->top=-1;         //top为整数且指向栈顶元素 
    }
    
    /*压栈操作*/
    Status PushStack(SqStack *S,Elemtype e)
    {
    	if(S->top >= MAXSIZE-1)
    	{
    		return ERROR;
    	}
    	S->elem[++S->top]=e;
    	return OK;
    }
    
    /*弹栈操作*/ 
    Status PopStack(SqStack *S,Elemtype *e)
    {
    	if(S->top == -1)
    	{
    		return ERROR;
    	}
    	*e = S->elem[S->top--];
    	return OK;
    }
    
    /*求栈长度*/
    Status StackLength(SqStack *S)
    {
    	return S->top+1;
    }
    
    int main()
    {
    	int sum=0,value,i,j;
    	Elemtype c;
    	SqStack S,S1;
    	
    	InitStack(&S);
    	
    	printf("请输入二进制数,以#结束输入:\n");
    	scanf("%c",&c);
    	while( c != '#')
    	{
    		if( c == '1'|| c == '0')
    		{
    			value=PushStack(&S,c);
    			if(!value)
    			{
    				printf("输入二进制数超过存储范围!\n");
    				return ERROR;
    			}
    			scanf("%c",&c);
    		}
    		else
    		{
    			printf("非法输入!\n");
    			return ERROR;
    		}
    	}
    	
    	getchar();                //把'\n'从缓冲区去掉 
    	
    	InitStack(&S1);
    	
    	int len=StackLength(&S);
    	for(i=0 ; i<len ; i+=3)
    	{
    		for(j=0;j<3;j++)      //三位二进制数对应一位八进制数 
    		{
    			PopStack(&S,&c);
    			sum += ( c - 48 ) * pow( 2 , j );
    			if(S.top == -1)
    			{
    				break;
    			}	
    		}
    		PushStack(&S1,sum+48);//八进制数转字符进行压栈 
    		sum=0;                //从新进行下一个字符转换 
    	} 
    	
    	printf("转化成八进制是:");
    	while( S1.top != -1)    //把转换好的八进制数以字符形式进行弹栈 
    	{
    		PopStack(&S1,&c);
    		printf("%c",c);	
    	}
    	printf("(O)\n"); 
    	return 0;	
    }
    

    2、二进制转十进制:

    /*二进制转十进制*/ 
    
    #include<stdio.h>
    #include<stdlib.h>
    #include<math.h>
    
    #define  MAXSIZE  20
    #define  ERROR    0
    #define  OK       1
    
    typedef int  Status;
    typedef char Elemtype;
    typedef struct{
    	Elemtype elem[MAXSIZE];
    	int top;
    }SqStack;
    
    void InitStack(SqStack *S)
    {
    	S->top=-1;
    }
    
    Status PushStack(SqStack *S,Elemtype e)
    {
    	if(S->top >= MAXSIZE-1)
    	{
    		return ERROR;
    	}
    	S->elem[++S->top]=e;
    	return OK;
    }
    
    Status PopStack(SqStack *S,Elemtype *e)
    {
    	if(S->top == -1)
    	{
    		return ERROR;
    	}
    	*e = S->elem[S->top--];
    	return OK;
    }
    
    /*求栈长度*/
    Status StackLength(SqStack *S)
    {
    	return S->top+1;
    }
    
    int main()
    {
    	int sum=0,value;
    	Elemtype c;
    	SqStack S;
    	
    	InitStack(&S);
    	
    	printf("请输入二进制数,以#结束输入:\n");
    	scanf("%c",&c);
    	while( c != '#')
    	{
    		if( c == '1'|| c == '0')
    		{
    			value=PushStack(&S,c);
    			if(!value)
    			{
    				printf("输入二进制数超过存储范围!\n");
    				return ERROR;
    			}
    			scanf("%c",&c);
    		}
    		else
    		{
    			printf("非法输入!\n");
    			return ERROR;
    		}
    	}
    	
    	getchar();      //把'\n'从缓冲区去掉 
    	
    	int len=StackLength(&S);
    	for(int i=0;i<len;i++)
    	{
    		PopStack(&S,&c);
    		sum += ( c - 48 ) * pow( 2 , i );
    	} 
    	printf("转换的十进制数为:"); 
    	printf("%d(D)\n",sum);
    	return 0;	
    }
    

    3、二进制转十六进制

    /*二进制转十六进制*/ 
    
    #include<stdio.h>
    #include<stdlib.h>
    #include<math.h>
    
    #define  MAXSIZE  20
    #define  ERROR    0
    #define  OK       1
    
    typedef int  Status;
    typedef char Elemtype;
    
    typedef struct{         //栈的静态分配存储结构 
    	Elemtype elem[MAXSIZE];
    	int top;
    }SqStack;
    
    void InitStack(SqStack *S)
    {
    	S->top=-1;         //top为整数且指向栈顶元素 
    }
    
    /*压栈操作*/
    Status PushStack(SqStack *S,Elemtype e)
    {
    	if(S->top >= MAXSIZE-1)
    	{
    		return ERROR;
    	}
    	S->elem[++S->top]=e;
    	return OK;
    }
    
    /*弹栈操作*/ 
    Status PopStack(SqStack *S,Elemtype *e)
    {
    	if(S->top == -1)
    	{
    		return ERROR;
    	}
    	*e = S->elem[S->top--];
    	return OK;
    }
    
    /*求栈长度*/
    Status StackLength(SqStack *S)
    {
    	return S->top+1;
    }
    
    int main()
    {
    	int sum=0,value,i,j;
    	Elemtype c;
    	SqStack S,S1;
    	
    	InitStack(&S);
    	
    	printf("请输入二进制数,以#结束输入:\n");
    	scanf("%c",&c);
    	while( c != '#')
    	{
    		if( c == '1'|| c == '0')
    		{
    			value=PushStack(&S,c);
    			if(!value)
    			{
    				printf("输入二进制数超过存储范围!\n");
    				return ERROR;
    			}
    			scanf("%c",&c);
    		}
    		else
    		{
    			printf("非法输入!\n");
    			return ERROR;
    		}
    	}
    	
    	getchar();                //把'\n'从缓冲区去掉 
    	
    	InitStack(&S1);
    	
    	int len=StackLength(&S);
    	for(i=0 ; i<len ; i+=4)
    	{
    		for(j=0;j<4;j++)      //四位二进制数对应一位十六进制数 
    		{
    			PopStack(&S,&c);
    			sum += ( c - 48 ) * pow( 2 , j );
    			if(S.top == -1)
    			{
    				break;
    			}	
    		}
    		
    		switch(sum)
    		{
    			case 10: 
    			case 11: 
    			case 12: 
    			case 13: 
    			case 14: 
    			case 15: sum+=55;break;//大于十转换成字母字符 
    			default :sum+=48;      //小于十转换成数字字符 
    			
    		} 
    		
    		PushStack(&S1,sum);   //把转换的字符进行压栈 
    		sum=0;                //从新进行下一个字符转换 
    	} 
    	
    	
    	printf("转化成十六进制是:");
    	while( S1.top != -1)    //把转换好的十六进制数以字符形式进行弹栈 
    	{
    		PopStack(&S1,&c);
    		printf("%c",c);	
    	}
    	printf("(H)\n"); 
    	return 0;	
    }
    

    4、运行效果截图如下:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 十进制转换成二进制 十进制转换成二进制,采用的是“除以2求余数”的计算方法,如下所示: “除以2”的过程,得到的余数是从低到高的次序,而需要的带的输出是从高位到低位(35对应的二进制是100011),因此需要一...
  • 进制转换原理 二进制转十进制 二进制是计算机数据的存储形式,它是由一串0和1组成,每个二进制数转换成相应的十进制数方法为: (XnXn-1Xn-2...X3X2X1)2 ...二进制转十六进制 利用二进制转十进制原理,从低位起
  • 资源限制 时间限制:1.0s 内存限制:512.0MB ...十六进制的计数方法是满16进1,所以十进制数16在十六进制中是10,而十进制的17在十六进制中是11,以此类推,十进制的30在十六进制中是1E。  给出...
  • 调用的基本操作(自由选择顺序或链栈),实现将一个十进制整数转换成2进制数的功能; 循环执行将十进制数除2的操作,将余数入栈。然后出栈输出可得二进制数的“序列”; 实现将十进制整数转换为N进制数的功能,N...
  • 实验目的:1、掌握的逻辑结构及存储结构;...完成数字十进制到八进制的转换。 输入示例: 请输入需转换的数的个数: 3 请输入需转换的数: 28,58,190 输出示例: 转换结果为: 1、 34 2、 72 3、 276
  • /*的应用: 1:需求:对于输入的任意一个非负十进制整数,打印输出与其等值的d进制数 2:思路:利用动态的后进先出的特性. 3: 步骤: 4:心得与体会: (1):这两天一直在想一个问题,如何才能实现动态中的元素...
  • 数据结构之 进制转换的数学计算方式 【代码实现】 using System; using System.Collections; namespace StackStruct { class StackApplication { public static void Decimalism2N(int number, int n) ....
  • 十进制转化为十六进制

    千次阅读 2020-10-26 10:05:01
    #include<iostream> #include<stdio.h> #include<stdlib.h> #include<string.h> #define MAXSIZE 100 using namespace std; typedef int ElemType;...int InitStack(SqStac.
  • DATAS SEGMENT ;数据段DATAS定义 CTR DB 0DH,0AH,'$' ;定义变量CTR, 内容为"0d0a$', 就是回车换行和$字符 DATAS ENDS CODES SEGMENT ...代码段,数据段和的声明 START: MOV AX,DATAS MOV DS,...
  • C++ 二进制、十进制、八进制和十六进制 转换

    万次阅读 多人点赞 2019-04-26 16:49:20
    如果要求按八进制或十六进制输入输出,在cin或cout中必须指明相应的数据形式,oct为八进制,hex为十六进制,dec为十进制。但是二进制没有默认的输出格式,需要自己写函数进行转换。 输入整数n , 则在C++中cout<&...
  • 十进制转十六进制的C语言实现

    千次阅读 2017-01-09 17:44:54
    #include #include #include void reversestr(char*source,char target[],unsigned int length); void tohex(unsigned long num,char*hexStr); int main() { ... printf("请输入一个十进制数:\n");
  • 是允许在同一端进行插入和删除操作的特殊线性表。允许进行插入和删除操作的一端称为栈顶(top),另一端为底(bottom);底固定,而栈顶浮动;中元素个数为零时称为空栈。插入一般称为进栈(PUSH),删除则...
  • } //十六进制转十进制,简单方法:Integer.parseInt(String s, int radix) public int SixteenTo10(String str) { int k = 0; switch(str) { case "0": k = 0; break; case "1": k = 1; break; case ...
  • 一.分析 二进制转换成十进制,就是从低位起用每一位去乘以对应位的积,也就是说用第n位去乘以2 * (n - 1),然后全部加起来
  • Python实现十进制和二进制、八进制、十六进制的相互转换1. 前言2. 实现思想2.1 十进制转换为其他进制2.2 其他进制转换为十进制3. 参考资料 1. 前言 此文方便后期的复习,如果有问题,欢迎批评指正。 2. 实现思想 2.1...
  • 利用实现把十进制数转换为二进制至十六进制之间的任一进制数并输出的功能。【实验题目内容】【实验环境】(使用的软件):VS - 2010【项目设计源代码】【项目测试运行结果截图】 【实验题目内容】 利用实现把...
  • 十进制十六进制数的方法···········整数部分,使用除16逆序取余法,将一个十进制的数,不断的除以16,直到该数小于16为止,每次都取余,整除就取0,然后从商开始由下而上的将余数串起来,这样子,...
  • hex :表示以十六进制输出 #include<iostream> using namespace std; int main() { int d; cin>>d; cout<<"八进制输出:"<<oct<<d<<endl; //八进制输出decNum cout<<"十六...
  • java_十进制数转换为二进制,八进制,十六进制数的算法
  • 10进制转16进制

    2021-03-12 11:01:13
    #include<winuser.inl> #include<stdio.h> #include <time.h> #include <cstdlib>... 的应用实例 -- 数进制转换 要求:输入任意的正整数N... 216(十进制) = 330(八进制) = D8(十六进制
  • 利用完成数制转换,能够完成十进制向八进制的转换 C++ 这里我采用的顺序存储结构 Source Code #include <stdio.h> #include <malloc.h> #define MaxSize 100 typedef int ElemType; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,309
精华内容 6,923
关键字:

十进制转十六进制栈