简介：这份资源面向C语言初学者与数据结构入门者，聚焦严蔚敏教材中数制转换这一经典例题，将原本以伪代码呈现的算法完整落地为可编译运行的C语言实例，帮助读者解决理解与调试上的困扰。压缩包内仅含1个PDF文件，约47KB，内容围绕顺序栈（SqStack）的定义与实现展开，涵盖栈的初始化、压栈、出栈、判空等基本操作，并给出完整的conversion()转换函数与OutList()输出函数代码。读者可从中掌握十进制转八进制（或其他进制）的核心思路：通过取余压栈、整除更新，再借助栈的后进先出特性逆序输出，从而得到正确结果。代码结构清晰，注释详尽，适合对照调试与动手实践。目前已有893人学习，对于想夯实数据结构基础、理解栈在实际算法中应用的读者，是一份轻量而实用的参考材料。

1. 从一道栈题说起：数制转换到底在练什么

很多人第一次在 C 语言数据结构课上见到数制转换，场景都差不多：老师丢下一句“用栈实现十进制转二进制”，然后就是交实验报告。可真到用的时候，比如给单片机写一个串口打印十六进制的调试函数，或者做协议解析时把一串字节转成可读的进制字符串，才发现当年抄的那份代码根本不敢用——负数没处理、零值直接输出空、缓冲区长度靠猜。数制转换看着简单，本质是“取余 + 逆序”这一个动作，而逆序恰好是栈最擅长的场景，所以它成了数据结构里讲栈的经典例题。这篇笔记不打算复述教材，而是把 C 语言数据结构中数制转换实例代码从能跑、到能扛边界、再到能直接嵌进项目，一层层拆开。适合正在学数据结构、准备 408 或者要写嵌入式底层工具函数的人，读完你能自己写出一个不翻车的版本。

2. 数制转换的数学骨架与栈的选型理由

2.1 短除法为什么天然需要后进先出

先把数学讲透，代码才不会变成玄学。十进制整数 N 转成 R 进制，标准做法是短除法：N 不断对 R 取余，余数就是当前最低位的数字，然后 N 除以 R 继续，直到 N 为 0。第一次得到的余数是个位，最后一次得到的是最高位。也就是说，余数的产生顺序和最终书写顺序正好相反。

举个具体例子，十进制 13 转二进制：

余数依次是 1、0、1、1，而 13 的二进制是 1101，正好是余数序列倒过来。这个“倒过来”就是栈的用武之地：把余数依次压栈，全部算完后依次弹栈，输出的就是正确顺序。用数组也能做，但需要额外记录下标再反向遍历，栈把这个逆序逻辑封装得更干净，也更贴合数据结构课程想训练的目标。

2.2 顺序栈和链栈在这里怎么选

教材里顺序栈和链栈都会讲，但落到数制转换这个具体问题，选型其实很明确。转换一个 32 位整数，最多需要多少位？二进制下 32 位，八进制下 11 位，十六进制下 8 位。也就是说栈的深度上限是固定的、很小的，完全没必要动态申请节点。

所以常见做法是用顺序栈，容量开 64 就绰绰有余，既没有 malloc 失败的风险，也没有链表指针跳转的开销。链栈在这里的唯一优势是“理论上不限深度”，但数制转换根本用不到这个特性。我一般会直接定义一个固定大小的数组栈，把 top 作为下标，压栈就是data[++top] = x，弹栈就是data[top--]。这种写法在单片机上尤其友好，不碰堆，栈空间可控。

提示：如果你的转换目标进制可能很大（比如自定义 62 进制），位数会变多，但 64 位整数在 62 进制下也才 11 位左右，64 容量依然够用。

2.3 一个最小可运行的顺序栈定义

下面这份代码是后面所有版本的基础，先把它跑通，再谈扩展。它只做十进制转二进制，但结构是通用的。

#include <stdio.h> #include <stdlib.h> #define STACK_SIZE 64 typedef struct { int data[STACK_SIZE]; /* 存余数，最大不会超过 64 位 */ int top; /* 栈顶下标，-1 表示空栈 */ } SeqStack; /* 初始化：把 top 置 -1，表示空栈 */ void stack_init(SeqStack *s) { s->top = -1; } /* 压栈：先判断是否溢出，再移动 top 并写入 */ int stack_push(SeqStack *s, int value) { if (s->top >= STACK_SIZE - 1) { return 0; /* 栈满，返回失败 */ } s->data[++(s->top)] = value; return 1; } /* 弹栈：通过出参带回栈顶元素，成功返回 1 */ int stack_pop(SeqStack *s, int *value) { if (s->top < 0) { return 0; /* 空栈，返回失败 */ } *value = s->data[(s->top)--]; return 1; } /* 十进制转二进制并打印 */ void dec_to_bin(int n) { SeqStack s; stack_init(&s); if (n == 0) { printf("0\n"); return; } while (n > 0) { stack_push(&s, n % 2); /* 余数入栈 */ n /= 2; /* 商继续参与下一轮 */ } int bit; while (stack_pop(&s, &bit)) { printf("%d", bit); /* 弹栈顺序即高位到低位 */ } printf("\n"); } int main(void) { dec_to_bin(13); dec_to_bin(0); return 0; }

逻辑说明：stack_push用前置自增把 top 从 -1 推到 0，第一个元素落在data[0]；stack_pop用后置自减先取值再降 top，保证弹栈顺序和压栈相反。参数说明：STACK_SIZE取 64 是保守值，覆盖 64 位整数在二进制下的全部位数；n % 2是当前位，n /= 2是短除法的商。这段代码跑出来 13 是 1101，0 是 0，符合预期。

3. 把实例代码扩展成通用 R 进制转换

3.1 支持 2 到 36 进制的映射表设计

只转二进制太窄，实际项目里十六进制用得更多。要支持任意进制，核心问题是：余数超过 9 之后怎么表示？答案是查表。准备一个字符数组"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"，余数 r 直接作为下标取字符，r 等于 10 就取到 'A'，15 取到 'F'。这样 2 到 36 进制一套逻辑全搞定。

这里有个容易忽略的点：栈里存的应该是字符还是数字？如果存数字，弹栈时再查表也行；如果压栈时直接存字符，弹栈直接打印更省事。我一般压栈时就把余数转成字符，因为转换只做一次，弹栈时不用再判断。但要注意，如果后续还要做数值运算，存数字更灵活。数制转换通常只为了显示，所以存字符是合理选择。

3.2 通用转换函数的完整实现

#include <stdio.h> #define STACK_SIZE 64 #define DIGITS "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" typedef struct { char data[STACK_SIZE]; /* 这次存字符，直接对应输出 */ int top; } CharStack; void cstack_init(CharStack *s) { s->top = -1; } int cstack_push(CharStack *s, char ch) { if (s->top >= STACK_SIZE - 1) { return 0; } s->data[++(s->top)] = ch; return 1; } int cstack_pop(CharStack *s, char *ch) { if (s->top < 0) { return 0; } *ch = s->data[(s->top)--]; return 1; } /* 把无符号整数 value 转成 base 进制，结果写入 buf */ int convert_base(unsigned int value, int base, char *buf, int buf_size) { if (base < 2 || base > 36) { return -1; /* 进制非法 */ } CharStack s; cstack_init(&s); if (value == 0) { if (buf_size < 2) return -1; buf[0] = '0'; buf[1] = '\0'; return 1; } while (value > 0) { int rem = value % base; /* 取当前最低位 */ cstack_push(&s, DIGITS[rem]); /* 查表转字符后入栈 */ value /= base; } int i = 0; char ch; while (cstack_pop(&s, &ch)) { if (i >= buf_size - 1) { return -1; /* 缓冲区不够，防止越界 */ } buf[i++] = ch; } buf[i] = '\0'; return i; /* 返回实际写入的字符数 */ } int main(void) { char buf[64]; convert_base(255, 16, buf, sizeof(buf)); printf("255 -> 16进制: %s\n", buf); convert_base(255, 2, buf, sizeof(buf)); printf("255 -> 2进制: %s\n", buf); convert_base(255, 8, buf, sizeof(buf)); printf("255 -> 8进制: %s\n", buf); return 0; }

逻辑说明：convert_base把“取余、查表、压栈”三步合成循环，弹栈时写入调用者提供的缓冲区，而不是直接 printf，这样函数可以被复用。参数说明：value用unsigned int是为了避免负数取余的符号问题，后面会专门讲负数；base限定 2 到 36，超出返回 -1；buf_size用于边界检查，防止写入越界。运行结果 255 的十六进制是 FF，二进制是 11111111，八进制是 377。

3.3 缓冲区长度到底该开多大

这是血泪经验最多的地方。很多人开char buf[32]就觉得够了，结果转二进制时 32 位整数需要 33 个字节（32 位数字加结束符），刚好越界一位，程序在栈上悄悄踩坏相邻变量，调试时现象千奇百怪。

安全做法是按最坏情况算：32 位无符号整数转二进制最多 32 位，加结束符 33；如果以后扩展到 64 位，就是 65。所以缓冲区至少开 64，稳妥点开 128。更规范的做法是让convert_base返回所需长度，调用者先判断再分配。下面这个表可以对照：

注意：不要用sprintf的返回值去猜长度，数制转换的位数和十进制位数不是一回事，必须按目标进制单独算。

4. 负数、零值和大数的边界处理

4.1 负数取余在 C 语言里的坑

C 语言里-13 % 2的结果是 -1，不是 1。如果你直接把负数丢进上面的循环，DIGITS[-1]会读到数组前面的非法内存，输出乱码甚至崩溃。这是数制转换实例代码里最常见的翻车点。

处理办法分两种。第一种是业务上根本不需要负数，那就把参数声明成unsigned，从类型层面堵死。第二种是确实要处理负数，常见做法是单独记录符号位，把数值取绝对值后再转换，最后在结果前面补一个负号。注意INT_MIN取绝对值会溢出，所以更稳的写法是先转成unsigned再取负：

/* 处理有符号整数的转换，支持负数 */ int convert_signed(int value, int base, char *buf, int buf_size) { int negative = 0; unsigned int mag; if (value < 0) { negative = 1; mag = (unsigned int)(-(value + 1)) + 1u; /* 避免 INT_MIN 溢出 */ } else { mag = (unsigned int)value; } char tmp[128]; int len = convert_base(mag, base, tmp, sizeof(tmp)); if (len < 0) return -1; int need = len + negative + 1; if (need > buf_size) return -1; int pos = 0; if (negative) buf[pos++] = '-'; for (int i = 0; i < len; i++) { buf[pos++] = tmp[i]; } buf[pos] = '\0'; return pos; }

逻辑说明：-(value + 1)先把 value 加 1 再取负，这样INT_MIN + 1不会溢出，然后再加 1 还原绝对值。参数说明：tmp作为中间缓冲，最后再拼符号，避免在原缓冲区上做插入操作。这个写法在 408 考研题里不常见，但工程里必须这么处理。

4.2 零值为什么会被输出成空字符串

看第一版代码，如果忘了if (n == 0)这个分支，while 循环一次都不进，栈是空的，弹栈循环也一次不进，最后 printf 什么都没输出。用户看到的就是一片空白，还以为程序没跑。零值必须单独处理，直接输出字符 '0'。这个坑在实验报告里扣分，在项目里就是 bug。

4.3 大数转换超出栈容量怎么办

前面说 64 容量够 64 位整数用，但如果你的场景是“把一个大整数（比如用数组表示的上百位十进制数）转成二进制”，位数可能上百，固定栈就不够了。这时候有两个方向：一是把栈容量按实际需求调大，二是改用动态栈。数据结构课程里讲的链栈在这里才真正派上用场。

不过要提醒一句，大数数制转换的难点不在栈，而在大数除法本身——你需要实现“大数除以一个小整数”的算法，逐位试商。栈只是最后逆序输出的工具。如果你的标题场景只是课程实验，不用碰这个；如果是做加密或高精度计算，那要单独设计。

5. 避坑与排查：数制转换实例代码的 5 个常见问题

5.1 输出顺序反了，最高位跑到最后

现象：输入 13，输出 1011 而不是 1101。原因：把余数直接按产生顺序打印，没有用栈逆序，或者压栈弹栈写反了。解决：确认余数是压栈后弹栈输出，弹栈循环必须在压栈循环全部结束之后。如果用的是数组，检查反向遍历的下标是不是从top开始递减。

5.2 十六进制输出小写，和协议对不上

现象：转换结果全是ff而不是FF。原因：映射表用了"0123456789abcdef..."。解决：把映射表改成大写，或者在输出时用toupper统一转换。协议里大小写敏感的场景很多，比如某些校验和计算，别在这里栽跟头。

5.3 栈顶指针初始值搞错导致首元素丢失

现象：输入 1，输出空或者少一位。原因：top初始化成 0 而不是 -1，压栈用data[top++]，第一个元素落在data[0]但 top 变成 1，弹栈时从data[1]开始读，data[0]被跳过。解决：统一约定空栈 top 为 -1，压栈用前置自增，弹栈用后置自减，全篇保持一致。

5.4 缓冲区越界但程序不报错

现象：转换结果偶尔多出乱码，或者相邻变量被改。原因：缓冲区开小了，或者没做buf_size检查。解决：按最坏位数开缓冲区，函数内部每次写入前判断i < buf_size - 1。在 Linux 下可以用valgrind或编译时加-fsanitize=address来抓越界。

5.5 负数转换输出带负号的乱码

现象：输入 -13，输出类似-1-0-1的东西。原因：负数直接参与取余，余数为负，查表越界。解决：按 4.1 的方式先取绝对值再转换，符号单独处理。如果不需要负数，参数直接用unsigned。

6. 进阶技巧：把转换函数做成可复用的调试工具

学完基础版本，真正让这份代码产生价值的地方是把它变成日常调试的顺手工具。我在嵌入式项目里最常用的一个习惯，是写一个hexdump风格的打印函数，把一段内存按十六进制输出，底层就是数制转换。下面这个技巧值得单独练。

先看一个把字节数组转成十六进制字符串的函数：

/* 把 data 指向的 len 个字节转成十六进制字符串，写入 out */ void bytes_to_hex(const unsigned char *data, int len, char *out, int out_size) { static const char HEX[] = "0123456789ABCDEF"; int pos = 0; for (int i = 0; i < len; i++) { if (pos + 3 >= out_size) break; /* 两个字符加一个空格 */ out[pos++] = HEX[data[i] >> 4]; /* 高四位 */ out[pos++] = HEX[data[i] & 0x0F]; /* 低四位 */ out[pos++] = ' '; } if (pos > 0) pos--; /* 去掉末尾空格 */ out[pos] = '\0'; }

逻辑说明：这里没有用栈，因为每个字节的高低位是固定两位，直接移位查表更快。但它和数制转换是同一个思想：把数值映射成字符。参数说明：data[i] >> 4取高四位，data[i] & 0x0F取低四位，这是十六进制转换的标准位运算写法。out_size检查保证不会越界。

再进一步，如果你要验证自己的转换函数是否正确，可以写一个反向解析函数，把字符串按指定进制转回整数，然后做往返测试。比如随机生成 1000 个整数，转成各进制字符串再转回来，比较是否相等。这种测试能抓出绝大多数边界 bug，比肉眼检查靠谱得多。

最后说个我自己的习惯：每次写完转换函数，先不急着集成，而是单独建一个测试文件，把上面表格里的用例全跑一遍，再随机跑几千次往返。数制转换的代码短，但边界多，靠肉眼 review 很容易漏。这个习惯帮我省过好几次通宵排查的麻烦。希望帮到你。

本文还有配套的精品资源，点击获取