（顺序栈 / 链式栈）编程实现功能：将十进制数，分别转换为八进制和十六进制。

短命女 2023-07-07 03:49 58阅读 0赞

更多资料请点击：[我的目录][Link 1]  
本篇仅用于记录自己所学知识及应用，代码仍可优化，仅供参考，如果发现有错误的地方，尽管留言于我，谢谢!

运行结果:  
![在这里插入图片描述][20200220190958782.png]

顺序栈版头文件：

#ifndef SEQSTACK_H //顺序栈头文件
    #define SEQSTACK_H
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <stdbool.h>
    
    // 顺序栈存储的元素类型，默认是int
    #ifndef SEQSTACK_NODE 
    #define SEQSTACK_NODE int
    #endif
    
    typedef SEQSTACK_NODE datatype;
    
    // 顺序栈的管理结构体
    typedef struct seqstack
    { 
    	int size;
    	int top;
    
    	datatype *data;
    }stack;
    
    
    static stack * init_stack(int size)
    { 
    	// 申请栈的管理结构体
    	stack * s = malloc(sizeof(stack));
    	if(s != NULL)
    	{ 
    		s->size = size;
    		s->top  = -1;	
    		s->data = calloc(size, sizeof(datatype));//给数据与申请内存
    
    		if(s->data == NULL)
    		{ 
    			free(s);
    			return NULL;
    		}
    	}
    	return s;
    }
    
    // 判断是否栈空
    static bool empty(stack *s)
    { 
    	return s->top == -1;
    }
    
    // 判断是否栈满
    static bool full(stack *s)
    { 
    	return s->top == s->size-1;
    }
    
    // 入栈
    static bool push(stack *s, datatype data)
    { 
    	// 栈已满，无法置入
    	if(full(s))
    	{ 
    		return false;
    	}
    	
    	else
    	{ 
    		s->data[++s->top] = data;//指向s栈顶 +1的栈（新栈顶）的值
    		return true;
    	}
    }
    
    // 出栈
    static bool pop(stack *s)
    { 
    	if(empty(s))
    	{ 
    		return false;
    	}
    	
    	else
    	{ 
    		s->top--;
    		return true;
    	}
    }
    
    // 取栈顶元素
    static bool top(stack *s, datatype *pdata)
    { 
    	if(empty(s))
    	{ 
    		return false;
    	}
    	
    	else
    	{ 
    		*pdata = s->data[s->top];//指向s栈顶元素
    		return true;
    	}
    }
    
    #endif

main函数：

#include <stdio.h>
    #define SEQSTACK_NODE char
    #include "seqstack.h"
    
    int main()
    { 
    	stack *s = init_stack(10);
    	printf("请输入一个十进制的整数:");
    	int x, y; char n;
    	scanf("%d", &x);
    	y = x;
    
    	while(x > 0)
    	{ 
    		push(s , x%8);
    		x /= 8 ;
    	}
    
    	printf("其八进制数为： 0");
    	while(!empty(s))
    	{ 
    		top(s,&n);
    		printf("%d",n);
    		pop(s);
    	}
    	printf("\n");
    	
    
    	while(!empty(s))
    	{ 
    		pop(s);
    	}
    	
    	char arr[17] = "0123456789ABCDEF";
    	while(y > 0)
    	{ 
    		push(s, arr[y%16]);
    		y /= 16;
    	}
    
    	printf("其十六进制数为：0x");
    	while(!empty(s))
    	{ 
    		top(s,&n);
    		printf("%c",n);
    		pop(s);
    	}
    	printf("\n");
    
    	return 0;
    }

链式栈版头文件：

#ifndef LINKSTACK_H
    #define LINKSTACK_H
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <stdbool.h>
    
    // 链式栈存储的元素类型，默认是int
    #ifndef LINKSTACK_NODE
    #define LINKSTACK_NODE int
    #endif
    
    typedef LINKSTACK_NODE datatype;
    
    // 链式栈数据节点的类型
    struct node
    { 
    	datatype data;
    	struct node *next;
    };
    
    // 链式栈的管理结构体
    typedef struct
    { 
    	struct node *top;// 指向链式栈的顶部元素，链栈为空时，top指向NULL
    	int size; //链式栈的大小
    
    }linkstack;
    
    // 初始化空栈
    static linkstack * init_stack()
    { 
    	linkstack * s = malloc(sizeof(linkstack));
    	if(s != NULL)
    	{ 
    		s->top  = NULL;
    		s->size = 0;
    	}
    	return s;
    }
    
    // 判断栈是否为空
    static bool empty(linkstack *s)
    { 
    	return s->size == 0;
    }
    
    // 入栈
    static bool push(linkstack *s, datatype data)
    { 
    	struct node *new = malloc(sizeof(struct node));
    	if(new != NULL)
    	{ 
    		new->data = data;
    		new->next = NULL;
    	}
    	else
    	{ 
    		return false;
    	}
    		
    	new->next = s->top;//节点new指向栈顶
    	s->top = new;//新栈顶为new
    
    	s->size++;//栈大小+1
    	return true;
    }
    
    // 出栈（即删除栈顶元素），并释放节点
    static void pop(linkstack *s)
    { 
    	if(empty(s))
    	{ 
    		return;
    	}
    	
    	else
    	{ 
    		struct node *p = s->top;//节点指向栈顶
    		s->top = s->top->next;//将栈顶指向栈顶的下一位（新栈顶）
    		s->size--;//栈大小-1
    
    		p->next = NULL;//节点p指向空
    		free(p);//释放p
    	}
    
    }
    
    // 取栈顶元素
    static struct node *top(linkstack *s)
    { 
    	if(empty(s))
    	{ 
     		return NULL;
    	}
    	else
    	{ 
    		return s->top;
    	}
    }
    
    #endif

main函数：

#include <stdio.h>
    #define SEQSTACK_NODE char
    #include "linkstack.h"
    
    int main()
    { 
    	// 初始化一个空栈
    	linkstack *s  = init_stack();
    	printf("请输入一个十进制的整数:");
    	// 将短除法中的余数，逐个入栈
    	int n;
    	scanf("%d", &n);
    
    	while(n > 0)
    	{ 
    		int tmp = n%16;
    		switch(tmp)
    		{ 
    		case 0 ... 9:
    			push(s, tmp+'0');
    			break;
    		case 10 ... 15:
    			push(s, tmp+'A'-10);
    			break;
    		}
    		n /= 16;
    	}
    
    	// 将栈中的元素，逐个出栈，得到结果
    	char a;
    	printf("其十六进制数为：0x");
    	while(!empty(s))
    	{ 
    		// 取栈顶
    		struct node *tmp = top(s);
    		printf("%c", tmp->data);
    
    		// 删除栈顶
    		pop(s);
    	}
    	printf("\n");
    	return 0;
    }

更多资料请点击：[我的目录][Link 1]

[Link 1]: http://note.youdao.com/noteshare?id=1370b0e8f4a16b80e7dede7836df3c08
[20200220190958782.png]: https://img-blog.csdnimg.cn/20200220190958782.png