写一个二叉树后序遍历的非递归算法用C语言

以下是使用C语言编写的二叉树后序遍历的非递归算法：

#include <stdio.h>
#include <stdlib.h>

#define MAX_STACK_SIZE 100

typedef struct TreeNode {
    int data;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

typedef struct Stack {
    TreeNode *data[MAX_STACK_SIZE];
    int top;
} Stack;

void initStack(Stack *stack) {
    stack->top = -1;
}

int isStackEmpty(Stack *stack) {
    return stack->top == -1;
}

int isStackFull(Stack *stack) {
    return stack->top == MAX_STACK_SIZE - 1;
}

void push(Stack *stack, TreeNode *node) {
    if (isStackFull(stack)) {
        printf("Stack overflow!\n");
        return;
    }
    stack->data[++stack->top] = node;
}

TreeNode *pop(Stack *stack) {
    if (isStackEmpty(stack)) {
        printf("Stack underflow!\n");
        return NULL;
    }
    return stack->data[stack->top--];
}

void postorderTraversal(TreeNode *root) {
    Stack stack;
    initStack(&stack);
    TreeNode *lastVisited = NULL;
    while (root || !isStackEmpty(&stack)) {
        if (root) {
            push(&stack, root);
            root = root->left;
        } else {
            TreeNode *temp = stack.data[stack.top];
            if (temp->right && temp->right != lastVisited) {
                root = temp->right;
            } else {
                printf("%d ", temp->data);
                lastVisited = pop(&stack);
            }
        }
    }
}

int main() {
    /* construct a binary tree */
    TreeNode *root = (TreeNode *) malloc(sizeof(TreeNode));
    TreeNode *node1 = (TreeNode *) malloc(sizeof(TreeNode));
    TreeNode *node2 = (TreeNode *) malloc(sizeof(TreeNode));
    TreeNode *node3 = (TreeNode *) malloc(sizeof(TreeNode));
    TreeNode *node4 = (TreeNode *) malloc(sizeof(TreeNode));
    TreeNode *node5 = (TreeNode *) malloc(sizeof(TreeNode));
    root->data = 1;
    node1->data = 2;
    node2->data = 3;
    node3->data = 4;
    node4->data = 5;
    node5->data = 6;
    root->left = node1;
    root->right = node2;
    node1->left = node3;
    node1->right = node4;
    node2->left = node5;
    node2->right = NULL;
    node3->left = NULL;
    node3->right = NULL;
    node4->left = NULL;
    node4->right = NULL;
    node5->left = NULL;
    node5->right = NULL;
    /* print postorder traversal */
    printf("Postorder traversal: ");
    postorderTraversal(root);
    printf("\n");
    return 0;
}

该算法使用了一个栈来存储节点，模拟递归过程。具体思路如下：

1. 初始化一个栈和一个指针`lastVisited`，该指针指向上一个被访问的节点，初始值为NULL。
2. 如果当前节点非空，将其压入栈中，并将当前节点指向其左子树。
3. 如果当前节点为空，则弹出栈顶节点，并进行以下判断：
1. 如果该节点有右子树且该右子树不是上一个被访问的节点，将当前节点指向该右子树。
2. 否则，说明该节点没有右子树或者其右子树已经被访问过，将其打印，并将`lastVisited`指向该节点，然后弹出栈顶节点。
4. 重复步骤2~3，直到栈为空。

以上就是二叉树后序遍历的非递归算法的C语言实现，希望对你有所帮助。