使用C语言，非递归实现二叉树算法，分别以前序，中序，后序遍历二叉树

下面是使用C语言，非递归实现二叉树前序、中序、后序遍历的代码：

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 100 // 栈的最大容量

// 二叉树节点结构体
typedef struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

// 栈结构体
typedef struct Stack {
    TreeNode* data[MAXSIZE];
    int top;
} Stack;

// 初始化栈
void init(Stack* s) {
    s->top = -1;
}

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

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

// 入栈
void push(Stack* s, TreeNode* node) {
    if (isFull(s)) {
        printf("Stack is full.\n");
        return;
    }
    s->data[++s->top] = node;
}

// 出栈
TreeNode* pop(Stack* s) {
    if (isEmpty(s)) {
        printf("Stack is empty.\n");
        return NULL;
    }
    return s->data[s->top--];
}

// 前序遍历二叉树
void preorderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    Stack s;
    init(&s); // 初始化栈
    push(&s, root); // 根节点入栈

    while (!isEmpty(&s)) {
        TreeNode* node = pop(&s); // 出栈并访问
        printf("%d ", node->val);

        // 先将右子树入栈，再将左子树入栈
        if (node->right != NULL) {
            push(&s, node->right);
        }
        if (node->left != NULL) {
            push(&s, node->left);
        }
    }
}

// 中序遍历二叉树
void inorderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    Stack s;
    init(&s); // 初始化栈
    TreeNode* p = root;

    while (p != NULL || !isEmpty(&s)) {
        // 左子树全部入栈
        while (p != NULL) {
            push(&s, p);
            p = p->left;
        }

        // 出栈并访问
        p = pop(&s);
        printf("%d ", p->val);

        // 开始遍历右子树
        p = p->right;
    }
}

// 后序遍历二叉树
void postorderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    Stack s;
    init(&s); // 初始化栈
    TreeNode* p = root;
    TreeNode* lastVisit = NULL;

    while (p != NULL || !isEmpty(&s)) {
        // 左子树全部入栈
        while (p != NULL) {
            push(&s, p);
            p = p->left;
        }

        // 查看栈顶元素，但不出栈
        p = s.data[s.top];

        // 如果栈顶元素的右子树为空，或者已经访问过，就可以访问根节点了
        if (p->right == NULL || p->right == lastVisit) {
            printf("%d ", p->val);
            pop(&s);
            lastVisit = p;
            p = NULL;
        } else {
            // 否则，开始遍历右子树
            p = p->right;
        }
    }
}

// 创建二叉树
TreeNode* createTree() {
    int val;
    printf("Enter node value (-1 for no node): ");
    scanf("%d", &val);
    if (val == -1) {
        return NULL;
    }
    TreeNode* node = (TreeNode*) malloc(sizeof(TreeNode));
    node->val = val;
    node->left = createTree();
    node->right = createTree();
    return node;
}

int main() {
    TreeNode* root = createTree();

    printf("Preorder traversal: ");
    preorderTraversal(root);
    printf("\n");

    printf("Inorder traversal: ");
    inorderTraversal(root);
    printf("\n");

    printf("Postorder traversal: ");
    postorderTraversal(root);
    printf("\n");

    return 0;
}

这段代码中，我们利用栈来实现非递归遍历二叉树。对于前序遍历，我们先将根节点入栈，然后每次出栈一个节点并访问，再将其右子树入栈，最后将其左子树入栈；对于中序遍历，我们先从根节点开始，将其所有左子树入栈，然后依次出栈并访问，再将其右子树入栈；对于后序遍历，我们需要记录上一个访问的节点，如果当前栈顶元素的右子树为空，或者已经访问过，就可以访问根节点了，否则，开始遍历右子树。