非递归实现二叉树遍历

二叉树的遍历有三种方式：先序遍历、中序遍历和后序遍历。在递归实现中，这三种遍历方式都很容易实现。但是在非递归实现中，需要使用栈来模拟递归的过程。具体实现方法如下：

1. 先序遍历：先访问根节点，然后访问左子树，最后访问右子树。使用栈来模拟递归的过程，先将根节点入栈，然后循环执行以下操作：弹出栈顶元素，访问该元素，如果该元素有右子树，则将右子树入栈，如果该元素有左子树，则将左子树入栈。

2. 中序遍历：先访问左子树，然后访问根节点，最后访问右子树。使用栈来模拟递归的过程，先将根节点入栈，然后循环执行以下操作：如果栈不为空或者当前节点不为空，执行以下操作：如果当前节点不为空，则将当前节点入栈，并将当前节点设置为左子树；如果当前节点为空，则弹出栈顶元素，访问该元素，将当前节点设置为右子树。

3. 后序遍历：先访问左子树，然后访问右子树，最后访问根节点。使用栈来模拟递归的过程，先将根节点入栈，然后循环执行以下操作：如果栈不为空，执行以下操作：获取栈顶元素，如果该元素没有子节点或者子节点已经被访问过，则弹出该元素并访问，否则将该元素的右子节点、左子节点依次入栈。

相关问题

递归和非递归实现二叉树中序遍历c

递归实现二叉树中序遍历的C代码如下：

void inorderTraversal(struct TreeNode* root){
    if(root){
        inorderTraversal(root->left);
        printf("%d ",root->val);
        inorderTraversal(root->right);
    }
}

非递归实现二叉树中序遍历的C代码如下：

void inorderTraversal(struct TreeNode* root){
    struct TreeNode* stack[1000];
    int top = -1;
    while(root || top != -1){
        while(root){
            stack[++top] = root;
            root = root->left;
        }
        if(top != -1){
            root = stack[top--];
            printf("%d ", root->val);
            root = root->right;
        }
    }
}

其中，我们使用一个栈来模拟递归过程，先将root的所有左子树节点入栈，然后再逐个弹出并访问栈顶节点，最后再访问右子树即可。

C语言非递归二叉树遍历用栈实现

二叉树的非递归遍历一般使用栈来实现。以下是 C 语言实现二叉树非递归遍历的示例代码：

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

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

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

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

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

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

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

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

// 二叉树非递归前序遍历
void preorderTraversal(struct TreeNode *root) {
    if (root == NULL) {
        return;
    }
    struct Stack s;
    initStack(&s);
    push(&s, root);
    while (!isEmpty(&s)) {
        struct 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(struct TreeNode *root) {
    if (root == NULL) {
        return;
    }
    struct Stack s;
    initStack(&s);
    struct TreeNode *node = root;
    while (node != NULL || !isEmpty(&s)) {
        while (node != NULL) {
            push(&s, node);
            node = node->left;
        }
        node = pop(&s);
        printf("%d ", node->val);
        node = node->right;
    }
}

// 二叉树非递归后序遍历
void postorderTraversal(struct TreeNode *root) {
    if (root == NULL) {
        return;
    }
    struct Stack s;
    initStack(&s);
    struct TreeNode *node = root;
    struct TreeNode *lastVisit = NULL;
    while (node != NULL || !isEmpty(&s)) {
        while (node != NULL) {
            push(&s, node);
            node = node->left;
        }
        node = s.data[s.top];
        if (node->right == NULL || node->right == lastVisit) {
            printf("%d ", node->val);
            lastVisit = node;
            node = NULL;
            pop(&s);
        } else {
            node = node->right;
        }
    }
}

int main() {
    struct TreeNode *root = (struct TreeNode *) malloc(sizeof(struct TreeNode));
    struct TreeNode *left = (struct TreeNode *) malloc(sizeof(struct TreeNode));
    struct TreeNode *right = (struct TreeNode *) malloc(sizeof(struct TreeNode));
    root->val = 1;
    root->left = left;
    root->right = right;
    left->val = 2;
    left->left = NULL;
    left->right = NULL;
    right->val = 3;
    right->left = NULL;
    right->right = NULL;
    printf("前序遍历结果：");
    preorderTraversal(root);
    printf("\n中序遍历结果：");
    inorderTraversal(root);
    printf("\n后序遍历结果：");
    postorderTraversal(root);
    return 0;
}

这里实现了二叉树的非递归前序、中序和后序遍历。需要注意的是，后序遍历的实现比较复杂，需要设置一个 lastVisit 指针来记录上一个访问的结点，以保证不重复访问。