数据结构笔记--前序、中序和后序遍历的递归与非递归实现

已于 2023-09-02 14:25:48 修改
阅读量318 收藏
点赞数
分类专栏： 数据结构&LeetCode 文章标签： 数据结构 算法
于 2023-08-10 20:10:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43863869/article/details/132216923
版权

目录

1--前序、中序和后序遍历的递归实现

1-1--前序遍历递归实现

1-2--中序遍历的递归实现

1-3--后序遍历的递归实现

2--前序、中序和后序遍历的非递归实现

2-1--前序遍历的非递归实现

2-2--后序遍历的非递归实现

2-3--中序遍历的非递归实现

1--前序、中序和后序遍历的递归实现

1-1--前序遍历递归实现

前序遍历顺序：根结点、左子树、右子树；

#include <iostream>
#include <vector>

struct TreeNode{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int value): val(value), left(NULL), right(NULL){};
};

class Solution{
public:
    std::vector<int> preorder(TreeNode *root){
        if(root == NULL) return res;

        res.push_back(root->val); // 根
        preorder(root->left); // 左
        preorder(root->right); // 右
        return res;
    }

    std::vector<int> res;
}; 

int main(int argc, char *argv[]){

    TreeNode *Node1 = new TreeNode(1);
    TreeNode *Node2 = new TreeNode(2);
    TreeNode *Node3 = new TreeNode(3);
    TreeNode *Node4 = new TreeNode(4);
    TreeNode *Node5 = new TreeNode(5);
    TreeNode *Node6 = new TreeNode(6);
    TreeNode *Node7 = new TreeNode(7);

    Node1->left = Node2;
    Node1->right = Node3;
    Node2->left = Node4;
    Node2->right = Node5;
    Node3->left = Node6;
    Node3->right = Node7;

    Solution S1;
    std::vector<int> res = S1.preorder(Node1);
    for(int num : res) std::cout << num << " ";

    return 0;
}

1-2--中序遍历的递归实现

中序遍历顺序：左子树、根节点、右子树；

#include <iostream>
#include <vector>

struct TreeNode{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int value): val(value), left(NULL), right(NULL){};
};

class Solution{
public:
    std::vector<int> inorder(TreeNode *root){
        if(root == NULL) return res;

        inorder(root->left); // 左
        res.push_back(root->val); // 根
        inorder(root->right); // 右
        return res;
    }

    std::vector<int> res;
}; 

int main(int argc, char *argv[]){

    TreeNode *Node1 = new TreeNode(1);
    TreeNode *Node2 = new TreeNode(2);
    TreeNode *Node3 = new TreeNode(3);
    TreeNode *Node4 = new TreeNode(4);
    TreeNode *Node5 = new TreeNode(5);
    TreeNode *Node6 = new TreeNode(6);
    TreeNode *Node7 = new TreeNode(7);

    Node1->left = Node2;
    Node1->right = Node3;
    Node2->left = Node4;
    Node2->right = Node5;
    Node3->left = Node6;
    Node3->right = Node7;

    Solution S1;
    std::vector<int> res = S1.inorder(Node1);
    for(int num : res) std::cout << num << " ";

    return 0;
}

1-3--后序遍历的递归实现

后序遍历顺序：左子树、右子树、根节点；

#include <iostream>
#include <vector>

struct TreeNode{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int value): val(value), left(NULL), right(NULL){};
};

class Solution{
public:
    std::vector<int> postorder(TreeNode *root){
        if(root == NULL) return res;

        postorder(root->left); // 左
        postorder(root->right); // 右
        res.push_back(root->val); // 根
        return res;
    }

    std::vector<int> res;
}; 

int main(int argc, char *argv[]){

    TreeNode *Node1 = new TreeNode(1);
    TreeNode *Node2 = new TreeNode(2);
    TreeNode *Node3 = new TreeNode(3);
    TreeNode *Node4 = new TreeNode(4);
    TreeNode *Node5 = new TreeNode(5);
    TreeNode *Node6 = new TreeNode(6);
    TreeNode *Node7 = new TreeNode(7);

    Node1->left = Node2;
    Node1->right = Node3;
    Node2->left = Node4;
    Node2->right = Node5;
    Node3->left = Node6;
    Node3->right = Node7;

    Solution S1;
    std::vector<int> res = S1.postorder(Node1);
    for(int num : res) std::cout << num << " ";

    return 0;
}

2--前序、中序和后序遍历的非递归实现

2-1--前序遍历的非递归实现

流程：初始化根节点入栈；

        ① 结点出栈，处理结点；

        ② 出栈结点的右儿子入栈，出栈结点的左儿子出栈；

        ③ 循环执行第 ① 步；

#include <iostream>
#include <vector>
#include <stack>

struct TreeNode{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int value): val(value), left(NULL), right(NULL){};
};

class Solution{
public:
    std::vector<int> preorder(TreeNode *root){
        if(root == NULL) return res;
        st.push(root); // 初始化根节点入栈
        while(!st.empty()){
            // 结点出栈
            TreeNode *tmp = st.top();
            st.pop();

            // 处理结点
            res.push_back(tmp->val);

            // 右儿子入栈
            if(tmp->right != NULL) st.push(tmp->right);
            // 左儿子入栈
            if(tmp->left != NULL) st.push(tmp->left);
        }
        return res;
    }

    std::vector<int> res;
    std::stack<TreeNode*> st;
}; 

int main(int argc, char *argv[]){

    TreeNode *Node1 = new TreeNode(1);
    TreeNode *Node2 = new TreeNode(2);
    TreeNode *Node3 = new TreeNode(3);
    TreeNode *Node4 = new TreeNode(4);
    TreeNode *Node5 = new TreeNode(5);
    TreeNode *Node6 = new TreeNode(6);
    TreeNode *Node7 = new TreeNode(7);

    Node1->left = Node2;
    Node1->right = Node3;
    Node2->left = Node4;
    Node2->right = Node5;
    Node3->left = Node6;
    Node3->right = Node7;

    Solution S1;
    std::vector<int> res = S1.preorder(Node1);
    for(int num : res) std::cout << num << " ";

    return 0;
}

2-2--后序遍历的非递归实现

流程：初始化两个栈，根节点入其中一个栈1，另一个栈2用于收集；

        ① 栈1的结点出栈；

        ② 出栈结点入收集栈2；

        ③ 出栈结点的左儿子入栈1，出栈结点的右儿子入栈1；

        ④ 重复第①步，直至栈1空；

        ⑤ 收集栈的结点依次出栈，此时顺序为后序遍历；

#include <iostream>
#include <vector>
#include <stack>

struct TreeNode{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int value): val(value), left(NULL), right(NULL){};
};

class Solution{
public:
    std::vector<int> postorder(TreeNode *root){
        if(root == NULL) return res;
        st1.push(root); // 初始化根节点入栈1
        while(!st1.empty()){
            // 结点出栈
            TreeNode *tmp = st1.top();
            st1.pop();

            // 出栈结点入收集栈2
           st2.push(tmp);

            // 左儿子入栈1
            if(tmp->left != NULL) st1.push(tmp->left);
            // 右儿子入栈1
            if(tmp->right != NULL) st1.push(tmp->right);
        }
        // 遍历收集栈2
        while(!st2.empty()){
            res.push_back(st2.top()->val);
            st2.pop();
        }
        return res;
    }

    std::vector<int> res;
    std::stack<TreeNode*> st1;
    std::stack<TreeNode*> st2;
}; 

int main(int argc, char *argv[]){

    TreeNode *Node1 = new TreeNode(1);
    TreeNode *Node2 = new TreeNode(2);
    TreeNode *Node3 = new TreeNode(3);
    TreeNode *Node4 = new TreeNode(4);
    TreeNode *Node5 = new TreeNode(5);
    TreeNode *Node6 = new TreeNode(6);
    TreeNode *Node7 = new TreeNode(7);

    Node1->left = Node2;
    Node1->right = Node3;
    Node2->left = Node4;
    Node2->right = Node5;
    Node3->left = Node6;
    Node3->right = Node7;

    Solution S1;
    std::vector<int> res = S1.preorder(Node1);
    for(int num : res) std::cout << num << " ";

    return 0;
}

2-3--中序遍历的非递归实现

流程：初始化一个栈，根节点入栈；

        ①：左子结点全部入栈；

        ②：结点出栈，处理结点；

        ③：对出栈结点的右子树执行第 ① 步操作；

#include <iostream>
#include <vector>
#include <stack>

struct TreeNode{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int value): val(value), left(NULL), right(NULL){};
};

class Solution{
public:
    std::vector<int> inorder(TreeNode *root){
        if(root == NULL) return res;
        while(!st.empty() || root != NULL){
            if(root != NULL){ // 左子结点全部入栈
                st.push(root);
                root = root->left;
            }
            else{
                TreeNode *tmp = st.top(); // 结点出栈
                st.pop(); 
                res.push_back(tmp->val);
                root = tmp->right; // 对出栈结点执行左子结点全部入栈的操作，即回到while循环判断
            }
        }
        return res;
    }

    std::vector<int> res;
    std::stack<TreeNode*> st;
}; 

int main(int argc, char *argv[]){

    TreeNode *Node1 = new TreeNode(1);
    TreeNode *Node2 = new TreeNode(2);
    TreeNode *Node3 = new TreeNode(3);
    TreeNode *Node4 = new TreeNode(4);
    TreeNode *Node5 = new TreeNode(5);
    TreeNode *Node6 = new TreeNode(6);
    TreeNode *Node7 = new TreeNode(7);

    Node1->left = Node2;
    Node1->right = Node3;
    Node2->left = Node4;
    Node2->right = Node5;
    Node3->left = Node6;
    Node3->right = Node7;

    Solution S1;
    std::vector<int> res = S1.inorder(Node1);
    for(int num : res) std::cout << num << " ";

    return 0;
}

晓晓纳兰容若
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言实现二叉树的前中后序遍历 递归和非递归 数据结构
03-23
1.输入前序和中序遍历结果，建立二叉树 2.实现二叉树的三种递归遍历算方法 3.实现二叉树的三种非递归遍历算法 4.实现二叉树的旋转90°后的打印，直观树形结构
二叉树的非递归遍历
weixin_30518397的博客
08-25 355
二叉树的非递归遍历 二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用...
【数据结构|二叉树遍历】递归与非递归实现前序遍历、中序遍历、后序遍历
zxcyxg123的博客
08-02 778
前序遍历（Preorder Traversal）： 前序遍历的顺序是先访问根节点，然后按照先左后右的顺序访问子节点。对于上面的二叉树，前序遍历的结果是：4 -> 2 -> 1 -> 3 -> 6 -> 5 -> 7。中序遍历（Inorder Traversal）： 中序遍历的顺序是按照先左后根再右的顺序访问子节点。对于上面的二叉树，中序遍历的结果是：1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7。
c语言先序非递归算法,数据结构与算法： C语言实现 前/中/后序的递归/非递归遍历...
weixin_34163125的博客
05-19 297
1.递归遍历递归遍历非常简单，，，，，，1.1前序遍历void preOrderTraverse(BSTreeNode *root){if (root != NULL){printf("%d \n", root->data);preOrderTraverse(root->left);preOrderTraverse(root->right);}}1.2中序遍历void InOrd...
递归和非递归方式实现二叉树的先序、中序和后序遍历
明朗晨光的专栏
06-18 1908
二叉树的递归实现和非递归实现、递归序
数据结构看书笔记---精选lazyfennec整理
11-15
二叉树的遍历方式有前序、中序和后序三种，常见的二叉树类型有完全二叉树和满二叉树。 四、排序与查找 排序是将一组数据按特定顺序排列的过程，常见的排序算法有冒泡排序、插入排序、选择排序、快速排序、归并排序...
数据结构（C语言描述）学习笔记.zip
01-01
比如，在二叉树中，递归地实现前序、中序和后序遍历，或者用栈实现非递归的层次遍历。 在实际应用中，数据结构往往结合算法一起使用，如排序算法（冒泡排序、快速排序、归并排序等）、搜索算法（二分查找、深度优先...
数据结构（C语言版）随堂笔记+习题答案.zip
最新发布
04-23
4. **树**：二叉树的性质，如满二叉树、完全二叉树、平衡二叉树，以及二叉树的遍历（前序、中序、后序）。 5. **图**：图的基本概念，邻接矩阵和邻接表的表示方法，深度优先搜索（DFS）和广度优先搜索（BFS）算法。...
数据结构----清华殷人昆数据结构笔记（C＋＋版，ppt格式）
04-02
清华大学的殷人昆教授是数据结构领域的权威专家，他的数据结构笔记因其深入浅出的讲解而备受赞誉。这些PPT资料以C++语言为背景，深入剖析了数据结构的核心概念和算法。 1. **线性表与数组**：数组是最基本的数据...
数据结构 考研复习笔记
09-19
还会涉及树的遍历方法（前序、中序、后序）和树的应用，如文件系统的目录结构。 4. **图结构**：包括图的定义、邻接矩阵和邻接表表示法，图的遍历（深度优先搜索DFS和广度优先搜索BFS），最小生成树（Prim算法和...
使用递归和非递归方式实现二叉树先序、中序、后序遍历
weixin_49561506的博客
12-31 1632
使用递归和非递归方式实现二叉树先序、中序、后序遍历
递归与非递归实现二叉树的前中后序遍历！！
weixin_64308540的博客
02-18 305
递归与非递归实现二叉树的前中后序遍历！！
二叉树的前序，中序，后序遍历（递归和非递归写法）
weixin_46060794的博客
07-09 1173
一、前序遍历 前序遍历是二叉树遍历的一种，也叫做先根遍历、先序遍历、前序周游，可记做根左右 前序遍历首先访问根结点然后遍历左子树，最后遍历右子树。在遍历左、右子树时，仍然先访问根节点，然后遍历左子树，最后遍历右子树。 若二叉树为空则结束返回，否则： （1）访问根结点。 （2）前序遍历左子树。 （3）前序遍历右子树 。 如图所示，前序遍历的结果为：ABDECFG 递归实现： ...
二叉树的前序遍历、中序遍历、后序遍历(递归+非递归实现)
qq_58284486的博客
04-01 4980
目录 前序遍历 递归实现 非递归实现 中序遍历 递归实现 递归实现 后序遍历 递归实现 非递归实现 二叉树是一种非常经典的数据结构，它的应用途径十分广泛，但同时它也是一种简单的、易理解的数据结构，解决二叉树问题的核心思想是递归，在初次接触到二叉树这种数据结构时，它的递归方式遍历很容易理解，但当要求以非递归方式来实现遍历时，就显得手足无措了，本篇博客以递归和非递归两种方式实现二叉树的遍历. 前序遍历 前序遍历的顺序为：首先访问根结点，然后遍历左子树，最...
二叉树的先序、中序、后序遍历（递归实现+非递归实现）
weixin_50991099的博客
07-11 1728
递归和栈分别实现二叉树的先序、中序、后序遍历
二叉树的前序、中序、后序遍历（递归和非递归）
qq_55928824的博客
02-24 279
二叉树的前序、中序、后序遍历（递归和非递归）
c语言前中后序的遍历算法,数据结构与算法： C语言实现 前/中/后序的递归/非递归遍历...
weixin_39989941的博客
05-24 164
1.递归遍历递归遍历非常简单，，，，，，1.1前序遍历void preOrderTraverse(BSTreeNode *root){if (root != NULL){printf("%d \n", root->data);preOrderTraverse(root->left);preOrderTraverse(root->right);}}1.2中序遍历void InOrd...
【算法】通过递归和非递归实现树的前中后序以及广度优先搜索和深度优先搜索
Zhangsama1的博客
05-14 765
树的前中后序以及BFS和DFS
递归、非递归实现二叉树先序、中序、后序遍历
hellogoxiaowu的博客
11-16 298
1.递归 //中序遍历 void inorder_traversal(Node* head) { if(head==NULL) return ; if(head->left!=NULL) inorder_traversal(head->left); printf("%d ",head->val); if(head->right!=NULL) inorder_traversal(head->right); } //先序遍历 void preorder_traversal
c++数据结构树的二叉树的前序中序后序遍历的递归与非递归代码包括输入与输出
06-06
好的，以下是C++数据结构中树的二叉树的前序、中序、后序遍历的递归与非递归代码，包括输入与输出。 假设二叉树的节点定义如下： ``` struct Node { int val; Node* left; Node* right; Node(int x) : val(x), left(NULL), right(NULL) {} }; ``` 前序遍历： 递归版本： ``` void preorderTraversal(Node* root) { if (!root) return; cout << root->val << " "; preorderTraversal(root->left); preorderTraversal(root->right); } ``` 非递归版本： ``` void preorderTraversal(Node* root) { stack<Node*> s; s.push(root); while (!s.empty()) { Node* node = s.top(); s.pop(); if (!node) continue; cout << node->val << " "; s.push(node->right); s.push(node->left); } } ``` 中序遍历： 递归版本： ``` void inorderTraversal(Node* root) { if (!root) return; inorderTraversal(root->left); cout << root->val << " "; inorderTraversal(root->right); } ``` 非递归版本： ``` void inorderTraversal(Node* root) { stack<Node*> s; Node* node = root; while (node || !s.empty()) { while (node) { s.push(node); node = node->left; } node = s.top(); s.pop(); cout << node->val << " "; node = node->right; } } ``` 后序遍历： 递归版本： ``` void postorderTraversal(Node* root) { if (!root) return; postorderTraversal(root->left); postorderTraversal(root->right); cout << root->val << " "; } ``` 非递归版本： ``` void postorderTraversal(Node* root) { stack<Node*> s; Node* node = root; Node* last = NULL; while (node || !s.empty()) { while (node) { s.push(node); node = node->left; } node = s.top(); if (!node->right || node->right == last) { cout << node->val << " "; s.pop(); last = node; node = NULL; } else { node = node->right; } } } ``` 输入与输出： ``` int main() { Node* root = new Node(1); root->left = new Node(2); root->right = new Node(3); root->left->left = new Node(4); root->left->right = new Node(5); root->right->left = new Node(6); root->right->right = new Node(7); cout << "前序遍历(递归): "; preorderTraversal(root); cout << endl; cout << "前序遍历(非递归): "; preorderTraversal(root); cout << endl; cout << "中序遍历(递归): "; inorderTraversal(root); cout << endl; cout << "中序遍历(非递归): "; inorderTraversal(root); cout << endl; cout << "后序遍历(递归): "; postorderTraversal(root); cout << endl; cout << "后序遍历(非递归): "; postorderTraversal(root); cout << endl; return 0; } ``` 输出结果： ``` 前序遍历(递归): 1 2 4 5 3 6 7 前序遍历(非递归): 1 2 4 5 3 6 7 中序遍历(递归): 4 2 5 1 6 3 7 中序遍历(非递归): 4 2 5 1 6 3 7 后序遍历(递归): 4 5 2 6 7 3 1 后序遍历(非递归): 4 5 2 6 7 3 1 ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值