C语言实现后续非递归遍历一棵树的代码—使用栈来实现。（可运行）

#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100

// 定义树节点的数据结构
typedef struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

// 定义栈的数据结构
typedef struct Stack {
    TreeNode* data[MAX_SIZE];
    int top;
} Stack;

// 初始化栈
Stack* initStack() {
    Stack* stack =(Stack*)malloc(sizeof(Stack));
    stack->top = -1;
    return stack;
}

// 判断栈是否为空
int isEmpty(Stack* stack) {
    return stack->top == -1;
}

// 判断栈是否已满
int isFull(Stack* stack) {
    return stack->top == MAX_SIZE - 1;
}

// 入栈
void push(Stack* stack, TreeNode* node) {
    if (isFull(stack)) {
        return;
    }
    stack->data[++stack->top] = node;
}

// 出栈
TreeNode* pop(Stack* stack) {
    if (isEmpty(stack)) {
        return NULL;
    }
    return stack->data[stack->top--];
}

// 获取栈顶元素
TreeNode* top(Stack* stack) {
    if (isEmpty(stack)) {
        return NULL;
    }
    return stack->data[stack->top];
}

// 后续遍历非递归
int* postorderTraversal(TreeNode* root, int* returnSize) {
    if (root == NULL) {
        *returnSize = 0;
        return NULL;
    }

    int* res = (int*)malloc(sizeof(int) * MAX_SIZE);
    int index = 0;
    TreeNode* prev = NULL;

    Stack* stack = initStack();
    while (root != NULL || !isEmpty(stack)) {
        while (root != NULL) {
            push(stack, root);
            root = root->left;
        }

        TreeNode* node = top(stack);
        
        if (node->right != NULL && node->right != prev) {
            root = node->right;
        } else {
            res[index++] = node->val;
            prev = node;
            pop(stack);
        }
    }

    *returnSize = index;
    return res;
}

int main() {
    // 创建一棵树
    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
    root->val = 1;
    root->left = (TreeNode*)malloc(sizeof(TreeNode));
    root->left->val = 2;
    root->left->left = NULL;
    root->left->right = NULL;
    root->right = (TreeNode*)malloc(sizeof(TreeNode));
    root->right->val = 3;
    root->right->left = NULL;
    root->right->right = NULL;

    int returnSize = 0;
    int* res = postorderTraversal(root, &returnSize);

    // 输出遍历结果
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", res[i]);
    }

    free(root->left);
    free(root->right);
    free(root);
    free(res);

    return 0;
}

 

在以上代码中，我们首先定义了树节点的数据结构TreeNode，以及栈的数据结构Stack。然后，通过定义相应的

操作函数来实现栈的基本操作。最后，我们定义了postorderTraversal函数来实现后续遍历的非递归实现。

在主函数中，我们创建一棵树，并调用postorderTraversal函数进行后续遍历，并将结果打印出来。

注意！！在使用之后，需要及时释放内存，避免内存泄漏。