C语言 | 实现二叉树的遍历

前序遍历(DFS)

leetcode第144. 二叉树的前序遍历

1、递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
void preTraversal(struct TreeNode* cur, int* ret, int* size) {
    if (cur == NULL) {
        return;
    }
    ret[(*size)++] = cur->val;
    preTraversal(cur->left, ret, size);
    preTraversal(cur->right, ret, size);
}

int* preorderTraversal(struct TreeNode* root, int* returnSize){
    int* ret = (int*)calloc(101, sizeof(int));
    int size = 0;
    preTraversal(root, ret, &size);
    *returnSize = size;
    return ret;
}

2、迭代

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* preorderTraversal(struct TreeNode* root, int* returnSize){
    int* ret = (int*)calloc(101, sizeof(int));
    *returnSize = 0;
    if (root == NULL) {
        return NULL;
    }
    /* 栈用于存储遍历过的节点 */
    struct TreeNode* stack[101];
    int top = 0;
    /* 初始节点为根节点 */
    struct TreeNode* cur = root;
    /* 初始top为0即栈为空，cur不为空；
     * 之后top大于0栈不为空，则树还没有遍历完，直到top为-1表示树遍历完成
     */
    while (top > 0 || cur != NULL) {
        /* 遇到一个新的节点将其入栈、填入返回数组中 */
        while (cur != NULL) {
            ret[(*returnSize)++] = cur->val;    /* 根 */
            stack[top++] = cur;
            cur = cur->left; /* 左 */
        }
        cur = stack[--top];
        cur = cur->right;   /* 右 */
    }
    return ret;
}

中序遍历(DFS)

leetcode第94. 二叉树的中序遍历

1、递归

同前序遍历，将递归函数的节点处理顺序调换即可：
根、左、右变为左、根、右

2、迭代

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* inorderTraversal(struct TreeNode* root, int* returnSize){
    int* ret = (int*)calloc(101, sizeof(int));
    *returnSize = 0;
    if (root == NULL) {
        return NULL;
    }
    /* 栈用于存储遍历过的节点 */
    struct TreeNode* stack[101];
    int top = 0;
    /* 初始节点为根节点 */
    struct TreeNode* cur = root;
    /* 初始top为0即栈为空，cur不为空；
     * 之后top大于0栈不为空，则树还没有遍历完，直到top为-1表示树遍历完成
     */
    while (top > 0 || cur != NULL) {
        /* 遇到一个新的节点将其入栈、填入返回数组中 */
        while (cur != NULL) {
            stack[top++] = cur;
            cur = cur->left; /* 左 */
        }
        cur = stack[--top];
        ret[(*returnSize)++] = cur->val;    /* 根 */
        cur = cur->right;   /* 右 */
    }
    return ret;
}

后序遍历(DFS)

leetcode第145. 二叉树的后序遍历

1、递归

同前序遍历，将递归函数的节点处理顺序调换即可：
根、左、右变为左、右、根

2、迭代

前序遍历为：根左右
后序遍历为：左右根
将前序遍历改为根右左，最后在翻转返回数组即可

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* postorderTraversal(struct TreeNode* root, int* returnSize){
    int* ret = (int*)calloc(101, sizeof(int));
    *returnSize = 0;
    if (root == NULL) {
        return NULL;
    }
    struct TreeNode* stack[101];
    int top = 0;
    struct TreeNode* cur = root;
    while (top > 0 || cur != NULL) {
        while (cur != NULL) {
            ret[(*returnSize)++] = cur->val;
            stack[top++] = cur;
            cur = cur->right;
        }
        cur = stack[--top];
        cur = cur->left;
    }
    for (int i = 0; i < *returnSize / 2; i++) {
        int tmp = ret[i];
        ret[i] = ret[*returnSize - 1 - i];
        ret[*returnSize - 1 - i] = tmp;
    }
    return ret;
}

层序遍历(BFS)

迭代

leetcode第102. 二叉树的层序遍历
1、维护一个队列用来记录当前层的节点
2、将每一层的节点入队列，再依次出队列并记录其值到返回数组中去；同时将本层节点的左右节点入队列
3、循环执行2，当队列头尾节点相等时结束即可

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
#define MAX_SIZE 10000
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    /* 特判 */
    *returnSize = 0;
    if (root == NULL) {
        return NULL;
    }

    /* 队列 */
    struct TreeNode* queue[MAX_SIZE];
    /* 返回数组 */
    int ** res = (int**)malloc(sizeof(int*) * MAX_SIZE);
    /* 返回数组每一行的个数 */
    *returnColumnSizes = (int*)malloc(sizeof(int) * MAX_SIZE);
    /* 队列的头尾指针 */
    int head = 0, rear = 0;
    /* 将根节点入队列 */
    queue[rear++] = root;
    /* 循环层序遍历树中节点 */
    while (head != rear) {
        /* 记录当前层的尾节点 */
        int preRear = rear;
        /* 当前层的节点数量 */
        int k = 0;
        /* 当前层返回数组的个数 */
        res[*returnSize] = (int*)malloc(sizeof(int) * (preRear - head));
        /* 依次遍历当前层节点 */
        while (head < preRear) {
            /* 出队 */
            struct TreeNode* p = queue[head];
            /* 更新返回数组中的值 */
            res[*returnSize][k++] = p->val;
            /* 将当前出队结点的左右节点入队 */
            if (p->left) {
                queue[rear++] = p->left;
            }
            if (p->right) {
                queue[rear++] = p->right;
            }
            /* 队列头结点向后移动一位 */
            head++;
        }
        /* 更新返回数组本层节点个数 */
        (*returnColumnSizes)[*returnSize] = k;
        (*returnSize)++;
    }    
    return res;
}