二叉树非递归的遍历c++代码

### 回答1：
好的，我可以帮助你写出二叉树的非递归遍历的 C 代码。

首先，二叉树的非递归遍历有两种方法：先序遍历和中序遍历。这里我们以先序遍历为例。

假设你已经定义了二叉树的结构体：

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

那么你可以这样写非递归的先序遍历代码：

void preorder_traversal(struct TreeNode *root) {
  if (root == NULL) {
    return;
  }
  struct TreeNode *stack[100];  // 定义一个栈
  int top = 0;  // top 指向栈顶元素
  struct TreeNode *p = root;  // 定义一个指针 p，用来遍历树

  while (p != NULL || top > 0) {
    while (p != NULL) {
      // 遍历到叶子结点就输出并将右儿子入栈
      printf("%d ", p->val);
      stack[top++] = p->right;
      p = p->left;
    }
    // 当 p 为空，说明已经到达了叶子结点，此时从栈中弹出一个元素作为当前遍历的结点
    p = stack[--top];
  }
}

在上述代码中，我们使用了一个栈来帮助我们在遍历过程中记录访问过的结点的右儿子。在遍历完一个结点的左子树后，我们就将这个结点的右儿子入栈，然后从栈中弹出一个元素作为当前的遍历结点。

我希望这段代码对你有

### 回答2：
二叉树非递归的遍历是通过利用栈来实现的。以下是二叉树非递归前序遍历的C++代码示例：

#include <iostream>
#include <stack>

using namespace std;

// 二叉树的结点定义
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

// 非递归前序遍历二叉树
void preOrderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }

    stack<TreeNode*> st;
    st.push(root);

    while (!st.empty()) {
        TreeNode* node = st.top();
        cout << node->val << " "; // 访问当前结点
        st.pop();

        // 先将右子树入栈，再将左子树入栈，因为栈是先进后出的结构，
        // 所以弹出时先弹出左子树结点，再弹出右子树结点，保证了前序遍历的顺序
        if (node->right != NULL) {
            st.push(node->right);
        }
        if (node->left != NULL) {
            st.push(node->left);
        }
    }
}

// 测试
int main() {
    // 构造一个二叉树
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);

    // 非递归前序遍历二叉树
    cout << "前序遍历结果：";
    preOrderTraversal(root); // 输出：1 2 4 5 3

    return 0;
}

以上是二叉树非递归的前序遍历的C++代码示例，通过栈的先进后出特性来模拟递归过程，实现非递归方式遍历二叉树的前序序列。代码中通过创建一个栈，并将根结点入栈，然后循环遍历栈，每次弹出栈顶结点，并访问该结点，然后依次将右子结点和左子结点入栈，保证了栈顶元素是下一个要遍历的结点。输出的结果为前序遍历的序列。

### 回答3：
二叉树的非递归遍历可以使用栈的数据结构来实现。具体的代码实现如下：

1.先定义二叉树的结构体类型：

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

2.中序遍历非递归代码：

void inOrderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    
    Stack* stack = createStack(); // 创建一个栈
    TreeNode* node = root;
    
    while (node != NULL || !isEmpty(stack)) {
        while (node != NULL) {
            push(stack, node); // 将当前节点入栈
            node = node->left; // 移动到左子节点
        }
        
        if (!isEmpty(stack)) {
            node = pop(stack); // 弹出栈顶节点
            printf("%d ", node->val); // 输出节点值
            node = node->right; // 移动到右子节点
        }
    }
}

3.前序遍历非递归代码：

void preOrderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    
    Stack* stack = createStack(); // 创建一个栈
    push(stack, root); // 将根节点入栈
    
    while (!isEmpty(stack)) {
        TreeNode* node = pop(stack); // 弹出栈顶节点
        printf("%d ", node->val); // 输出节点值
        
        // 先将右子节点入栈，再将左子节点入栈，这样出栈时才能先左后右
        if (node->right != NULL) {
            push(stack, node->right);
        }
        if (node->left != NULL) {
            push(stack, node->left);
        }
    }
}

4.后序遍历非递归代码：

void postOrderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    
    Stack* stack1 = createStack(); // 创建第一个栈
    Stack* stack2 = createStack(); // 创建第二个栈
    push(stack1, root); // 将根节点入栈
    
    while (!isEmpty(stack1)) {
        TreeNode* node = pop(stack1); // 弹出栈顶节点
        push(stack2, node); // 将弹出的节点入第二个栈
        
        if (node->left != NULL) {
            push(stack1, node->left); // 先将左子节点入第一个栈
        }
        if (node->right != NULL) {
            push(stack1, node->right); // 再将右子节点入第一个栈
        }
    }
    
    while (!isEmpty(stack2)) {
        TreeNode* node = pop(stack2); // 弹出第二个栈的节点
        printf("%d ", node->val); // 输出节点值
    }
}

以上便是二叉树的非递归遍历代码实现。需要注意的是，在代码中使用了一个栈的数据结构来辅助实现遍历过程。