我们知道的东西是有限的，而我们不知道的东西则是无穷的。——拉普拉斯

字符型与数值转换

• val -> str，数值到字符串的转换 sprintf()。
• str -> val，字符串到数值的转换atoi()和sscanf()和。或自己实现：取从高到低取每个字符与'0'相减，并不断乘10累加进位。

用法示例：

• int i = atoi(str)可以用sscanf(str, "%d", &i)替代。
• long l = strtol(str, NULL, 10)，可以用sscanf(str, "%ld", &l)替代。
• sprintf(str, "%ld", l)，则将长整型l的值转换成字符，拷贝到字符串str中。

相关文章：C学习：一网打尽字符串骚操作

将数组值输出打印到文本文件

文件输出综合应用范例，涉及库函数: fopen/fclose/fprintf(格式化输出)。

功能1：将变量值打印到文本文件中。

#include <stdio.h>
#define Q2_MAX_NUMBITS 8
const float Q2_NORM0[Q2_MAX_NUMBITS + 1] = {
   
    1., 2., 4., 8., 16., 32., 64., 128.
};

int main(void)
{
   
    FILE *outStream = fopen("D:\\workspace\\outstream.txt", "w+"); // a+在文件末尾追加, w+每次从头开始写
    int i;
    fprintf(outStream, "Q2_NORM0");
    for (i = 0; i < Q2_MAX_NUMBITS + 1; i++) {
   
        if (i % 4 == 0) {
    // 隔四个元素换行
            fprintf(outStream, "\n");
        }
        fprintf(outStream, "%f, ", Q2_NORM0[i]);
    }
    fprintf(outStream, "\n\n");
    fclose(outStream);
    return 0;
}

功能2：将整型数转换成0x121212的16进制HEX表达的整型数。

#include <stdio.h>
#define Q2_MAX_NUMBITS

const float Q2_NORM0[Q2_MAX_NUMBITS + 1] = {
   
    1., 2., 4., 8., 16., 32., 64., 128.
};

int main(void)
{
   
    FILE *outStream = fopen("D:\\workspace\\outstream.txt", "w+"); // a+在文件末尾追加, w+每次从头开始写
    int i;
    fprintf(outStream, "Q2_NORM0 HEX");
    for (i = 0; i < Q2_MAX_NUMBITS + 1; i++) {
   
        if (i % 4 == 0) {
    // 隔四个元素换行
            fprintf(outStream, "\n");
        }
        fprintf(outStream, "0x%08x, ", (int)Q2_NORM0[i]); // 08x控制输出的十六进制，用8个字符，不足的用0补齐，一个字符表示4位，共表示32位
    }
    fprintf(outStream, "\n\n");
    fclose(outStream);
    return 0;
}

参考：C语言的十六进制如何指定位宽----0x16输输出为0x0016?

动态申请二维数组

// 申请对应大小的二维数组并分配空间
int **resArr = (int **)malloc(depth * sizeof(int*));
if (resArr == NULL) {
   
    return NULL;
}
int *p;
int i;
for (i = 0; i < depth; i++) {
   
    p = (int*)malloc(numsSize * sizeof(int));
    if (p == NULL) {
   
        return NULL;
    }
    resArr[i] = p;
}

BFS遍历模板

struct TreeNode {
   
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

typedef struct QueNode {
    // BFS必备队列链表数据结构
    int depth;
    struct TreeNode *node;
    struct QueNode *next;
} StruQueNode;

void InitQueList(StruQueNode **queList, struct TreeNode* node, int depth)
{
   
    *queList = (StruQueNode *)malloc(sizeof(StruQueNode));
    if (*queList == NULL) {
   
        return;
    }
    (*queList)->depth = depth;
    (*queList)->node = node;
    (*queList)->next = NULL;
    return;
}
int g_curLevelCnt;
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes)
{
   
    if (root == NULL) {
   
        return NULL;
    }

    StruQueNode *queList, *queListHead, *queLastNode;
    InitQueList(&queList, root, 1);
    queLastNode = queList;
    queListHead = queList;
    g_curLevelCnt = 1;

    // BFS
    int depth = 1;
    struct TreeNode* node;
    while (queList != NULL) {
   
        // 当前层遍历
        while (depth == queList->depth) {
   
            node = queList->node;
            if (node->left != NULL) {
   
                InitQueList(&queLastNode->next, node->left, depth + 1);
            }
            queLastNode = queLastNode->next; // 记录队列Add尾部节点
            if (node->right != NULL) {
   
                InitQueList(&queLastNode->next, node->right, depth + 1);
            }
            queLastNode = queLastNode->next;
            queList = queList->next; // 当前层下一个节点
        }
        depth++; // 遍历完一层
    }
    *returnSize = depth;

}