二叉树非递归遍历

以下是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*> s;
    s.push(root);
    while (!s.empty()) {
        TreeNode* node = s.top();
        s.pop();
        cout << node->val << " "; // 访问当前节点
        if (node->right) s.push(node->right); // 右子节点入栈
        if (node->left) s.push(node->left); // 左子节点入栈
    }
    cout << endl;
}

void inOrderTraversal(TreeNode* root) {
    // 中序遍历：左 -> 根 -> 右
    if (root == NULL) return;
    stack<TreeNode*> s;
    TreeNode* curr = root;
    while (curr != NULL || !s.empty()) {
        while (curr != NULL) {
            s.push(curr);
            curr = curr->left; // 一直向左走
        }
        curr = s.top();
        s.pop();
        cout << curr->val << " "; // 访问当前节点
        curr = curr->right; // 转向右子节点
    }
    cout << endl;
}

void postOrderTraversal(TreeNode* root) {
    // 后序遍历：左 -> 右 -> 根
    if (root == NULL) return;
    stack<TreeNode*> s1, s2;//这里需要两个栈 
    s1.push(root);//还是先把根节点压入栈1 
    while (!s1.empty()) {
        TreeNode* node = s1.top();
        s1.pop();
        s2.push(node);//把s1弹出来的压入s2 
        if (node->left) s1.push(node->left);//如果左右结点不为空就压入s1 
        if (node->right) s1.push(node->right);
    }
    while (!s2.empty()) {
        cout << s2.top()->val << " ";
        s2.pop(); 
    }
    cout << endl;
}

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);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);
    
    cout << "前序遍历: ";
    preOrderTraversal(root);
    cout << "中序遍历: ";
    inOrderTraversal(root);
    cout << "后序遍历: ";
    postOrderTraversal(root);
    
    // 释放二叉树内存，注意从下往上删，要不然先删了root其他点就游离出去找不到了 
    delete root->left->left;
    delete root->left->right;
    delete root->right->left;
    delete root->right->right;
    delete root->left;
    delete root->right;
    delete root;
    
    return 0;
}

这是运行结果：

再往下就是纯c语言版的代码了，鼠鼠我啊偷懒用AI转换了下，不得不说，是真强大啊！

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

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

typedef struct TreeNode *Position;
typedef struct Stack {
    Position *elements;
    int maxSize;
    int top;
} Stack;

void push(Stack *s, Position element) {
    if (s->top == s->maxSize - 1) {
        printf("栈已满，无法入栈。\n");
        return;
    }
    s->elements[++s->top] = element;
}

Position pop(Stack *s) {
    if (s->top == -1) {
        printf("栈为空，无法出栈。\n");
        return NULL;
    }
    return s->elements[s->top--];
}

int isEmpty(Stack *s) {
    return s->top == -1;
}

Position createNode(int data) {
    Position newNode = (Position)malloc(sizeof(TreeNode));
    if (!newNode) {
        printf("创建节点失败。\n");
        return NULL;
    }
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

void preOrderTraversal(TreeNode *root) {
    if (root == NULL) return;
    Stack s;
    s.elements = (Position *)malloc(sizeof(Position) * 100); // 假设栈的最大容量为100
    s.maxSize = 100;
    s.top = -1;
    push(&s, root);
    while (!isEmpty(&s)) {
        Position current = pop(&s);
        printf("%d ", current->data);
        if (current->right) push(&s, current->right);
        if (current->left) push(&s, current->left);
    }
    free(s.elements);
}

void inOrderTraversal(TreeNode *root) {
    if (root == NULL) return;
    Stack s;
    s.elements = (Position *)malloc(sizeof(Position) * 100); // 假设栈的最大容量为100
    s.maxSize = 100;
    s.top = -1;
    Position current = root;
    while (current != NULL || !isEmpty(&s)) {
        while (current != NULL) {
            push(&s, current);
            current = current->left;
        }
        current = pop(&s);
        printf("%d ", current->data);
        current = current->right;
    }
    free(s.elements);
}

void postOrderTraversal(TreeNode *root) {
    if (root == NULL) return;
    Stack s1, s2;
    s1.elements = (Position *)malloc(sizeof(Position) * 100); // 假设栈的最大容量为100
    s1.maxSize = 100;
    s1.top = -1;
    s2.elements = (Position *)malloc(sizeof(Position) * 100); // 假设栈的最大容量为100
    s2.maxSize = 100;
    s2.top = -1;
    push(&s1, root);
    while (!isEmpty(&s1)) {
        Position current = pop(&s1);
        push(&s2, current);
        if (current->left) push(&s1, current->left);
        if (current->right) push(&s1, current->right);
    }
    while (!isEmpty(&s2)) {
        Position current = pop(&s2);
        printf("%d ", current->data);
    }
    free(s1.elements);
    free(s2.elements);
}

int main() {
    // 构建一棵二叉树
    TreeNode *root = createNode(1);
    root->left = createNode(2);
    root->right = createNode(3);
    root->left->left = createNode(4);
    root->left->right = createNode(5);
    root->right->left = createNode(6);
    root->right->right = createNode(7);
    
    printf("前序遍历: ");
    preOrderTraversal(root);
    printf("\n中序遍历: ");
    inOrderTraversal(root);
    printf("\n后序遍历: ");
    postOrderTraversal(root);
    printf("\n");
    
    // 释放二叉树内存
    free(root->left->left);
    free(root->left->right);
    free(root->right->left);
    free(root->right->right);
    free(root->left);
    free(root->right);
    free(root);
    
    return 0;
}

最后贴上我上一个帖子写的dfs代码，dfs（递归深搜）是真好用啊（doge）（树的图片在我另外一篇文章二叉树遍历里面有，不过各位ｄａｌａｏ应该能一眼看出来（膜拜））

//以下是数据结构的二叉树遍历
 
#include<stdio.h>
#include<stdlib.h>
 
typedef struct Node{
	int data;//树节点的值,这里设为int类型 
	struct Node* lchild;
	struct Node* rchild;//定义左孩子，右孩子 
}Node;
 
typedef struct Node* PNode;
 
//下面开始建树
//树的图片我放下面了
PNode head;//搞一个head指针准备指向根节点 ，不过这里头节点好像没用上hh，大伙不用管它 
PNode node[10];
 
void Bulid(){
	head=(PNode)malloc(sizeof(Node));//给头节点空间 
	
	for(int i=0;i<10;i++){
		node[i]=(PNode)malloc(sizeof(Node));//给10个节点空间 
		node[i]->lchild=NULL;
		node[i]->rchild=NULL;//先将每个节点的左右儿子全部置空 
	}
	
	for(int i=0;i<10;i++){
		node[i]->data=i+1;//node[0]->data=1,以此类推 
	}
	
	head->lchild=node[0];//拿head的左儿子去当连接根节点
	head->rchild=NULL;//右儿子置空 
	
	node[0]->lchild=node[1];
	node[0]->rchild=node[2];
	node[1]->lchild=node[3];
	node[1]->rchild=node[4];
	node[3]->lchild=node[5];
	node[2]->lchild=node[6];
	node[2]->rchild=node[7];
	node[6]->lchild=node[8];
	node[8]->lchild=node[9];
	//吧啦吧啦，至此粗鲁建树完成 
}
 
void dfs(PNode t){
	//递归打印先序遍历
	 if(t!=NULL){
	 	printf("%d ",t->data);//语句的位置决定了打印出来的是什么遍历 ，放这是先序 
	 	dfs(t->lchild);//搜索该节点左子树  
	 	//放这是中序 
	 	dfs(t->rchild);//搜索该节点右子树
		//放这是后序 
	 }
	 else return;
} 
 
int main(){
	Bulid();
	dfs(node[0]);
	return 0;
}