二叉树的遍历

AARON_MJT

已于 2022-09-01 21:40:25 修改

阅读量109

点赞数

分类专栏：数据结构与算法文章标签：数据结构

于 2022-07-20 20:12:23 首次发布

本文链接：https://blog.csdn.net/m0_54711064/article/details/125899551

版权

数据结构与算法专栏收录该内容

9 篇文章 0 订阅

订阅专栏

二叉树的遍历

递归
ret容器，用于保存输出
dft容器，用于输出空数组

1、前序遍历

144. 二叉树的前序遍历
在这里插入图片描述

class Solution {
    vector<int> ret;
    vector<int> dft;
public:   
    vector<int> preorderTraversal(TreeNode* root) {  
        if(root == nullptr) return dft;
        ret.push_back(root->val);
        preorderTraversal(root->left);
        preorderTraversal(root->right);
        return ret;
    }
};

2、中序遍历

94. 二叉树的中序遍历
在这里插入图片描述

class Solution {
    vector<int>ret;
    vector<int>dfs;
public:
    vector<int> inorderTraversal(TreeNode* root) {
        if(root == nullptr) return dfs;
        inorderTraversal(root->left);
        ret.push_back(root->val);
        inorderTraversal(root->right);
        return ret;
    }
};

3、后序遍历

145. 二叉树的后序遍历
在这里插入图片描述

class Solution {
    vector<int>ret;
    vector<int>dfs;
public:
    vector<int> postorderTraversal(TreeNode* root) {
        if(root == nullptr) return dfs;
        postorderTraversal(root->left);
        postorderTraversal(root->right);
        ret.push_back(root->val);
        return ret;
    }
};

4、层序遍历

102. 二叉树的层序遍历

迭代广度优先搜索BFS：层层推进，遍历每一层的节点。
1、BFS需要用队列作为辅助结构，先将根节点放到队列中，然后不断遍历队列；
2、首先拿出根节点3，如果左子树/右子树不为空，就将它们放入队列中。第一遍处理完后，根节点已经从队列中pop()走了，而根节点的两个孩子已经放入队列中了，现在队列中就只有两个节点9和20；
3、第二次处理，会将9和20这两个节点从队列中拿走，然后再将9和20的子节点放入队列中，现在队列中就有两个节点15和7；
4、我们把每层遍历到的节点都放入到一个结果集中，最后返回这个结果集就可以了。

在这里插入图片描述

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        //迭代 广度优先搜索BFS
        vector<vector<int>> ret;

        queue<TreeNode*>que;
        if(root == nullptr) return ret;
        que.push(root);
        while(!que.empty()){
            vector<int> tmp;
            int n = que.size();
            while(n--){
                TreeNode* tn = que.front(); que.pop();
                tmp.push_back(tn->val);
                if(tn->left != nullptr) que.push(tn->left);
                if(tn->right != nullptr) que.push(tn->right);
            }
            ret.push_back(tmp);
        }
        return ret;
    }
};

5、二叉树括号表示法

#include <iostream>
#include <string>
#include <algorithm>
#include <stack>

using namespace std;

/*
* 本次要实现是使用类似 “A(B(C),D(,E))” 这样的字符串构建、输出二叉树的代码。
* 括号表示法表示规则：以字符来表示结点，结点后紧跟的括号表示此结点的孩子结点，
* 例如树 “A(B,C)”，若孩子结点后面还有孩子结点，也按照此方法递归表示。兄弟结点之间使用逗号分隔。
* 需要注意的是，如果结点A后面只有一个左孩子B，那么表示成这样 “A(B)”，而如果结点A后面只有一个右孩子B，则是“A(,B)”。
*/


//树节点定义，写了一个简单的构造函数
struct Node {
    char data;
    Node* lchild;
    Node* rchild;

    Node(char c = '\0') : data(c), lchild(NULL), rchild(NULL) {}
};

Node* createTree(string& s) {

    Node* root = NULL;  //最后要返回的树根结点
    Node* cur = NULL;   //当前节点
    stack<Node*> stk;   //辅助栈
    //flag用来标记当前节点是父节点的哪个孩子，左孩子还是右孩子
    int flag = 0; // 1 -> lchild, 2 -> rchild, 0 -> nothing 
    for (char c : s) {
        switch (c) {
        case '(':    //遇到左括号意味着当前的cur结点有孩子结点，入栈并标记下一个孩子应该是此结点的左孩子
            if (!cur)
                cout << "error" << endl;
            stk.push(cur);
            flag = 1;
            break;

        case ')':   //表示该结点的孩子已经处理完毕，出栈该结点
            stk.pop();
            break;

        case ',':   //遇到逗号表示下一个结点应是一个右孩子结点，使用flag标记
            flag = 2;
            break;

        default:    //遇到字符的情况，创建节点并判断该节点是上一个节点的左孩子还是右孩子
            cur = new Node(c);
            if (!root)  //根为空，当前的cur就是根结点
                root = cur;
            if (flag == 1)
                stk.top()->lchild = cur;
            else if (flag == 2)
                stk.top()->rchild = cur;
            flag = 0;

            break;
        }
    }
    return root;    //最后返回根结点
}

void print(Node* p) {
    if (!p)                             //p为空直接返回
        return;
    cout << p->data;                    //能执行到这里说明p不空，输出p的data
    if (p->lchild || p->rchild) {       //如果有孩子结点再处理
        cout << "(";                    //有孩子结点，输出左括号
        print(p->lchild);               //这里直接递归，如果左孩子为空会直接返回，不空会递归输出
        if (p->rchild) {
            cout << ",";                //有右孩子则输出逗号并递归输出右孩子的孩子
            print(p->rchild);
        }
        cout << ")";                    //最后输出右括号
    }
}

void preorder(Node* p) {
    if (!p)
        return;
    cout << p->data << " ";
    preorder(p->lchild);
    preorder(p->rchild);
}

void inorder(Node* p) {
    if (!p)
        return;
    inorder(p->lchild);
    cout << p->data << " ";
    inorder(p->rchild);
}

void postorder(Node* p) {
    if (!p)
        return;
    postorder(p->lchild);
    postorder(p->rchild);
    cout << p->data << " ";
}


//销毁二叉树
//树的销毁函数，必须是这种类似后序遍历的写法，遍历完左右孩子再delete父节点
void destory(Node* p) {
    if (!p)
        return;
    destory(p->lchild);
    destory(p->rchild);
    delete p;
}


//由于递归输出无法处理最后的换行，需要teaverse函数处理换行
void traverse(void(tFunc)(Node* p), Node* root) {
    tFunc(root);
    cout << endl;
}

int main() {
    Node* root = NULL;
    string s = "A(B(C,D),E(F,G))";
    //string s = "49(28(14,31),53(50,64))";
    cout << s << endl;
    root = createTree(s);
    traverse(preorder, root);
    //traverse(inorder, root);
    //traverse(postorder, root);
    print(root);
    destory(root);
    return 0;
}

6、二叉树中序遍历—递增排序

排序二叉树：

每个节点中包含一个关键值
任意一个节点的左子树的关键值小于该节点的关键值
任意一个节点的右子树的关键值大于该节点的关键值

给定一组数据，建立一颗二叉树，输出其中的中序遍历的结果 -->> 递增的

#include <stdio.h>
#include <stdlib.h>
#define maxsize 10001
int j;
typedef struct BiTNode
{
    int data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
BiTree CreatBiTree(BiTree r,int m)
{
    BiTree p,q,w;
        p = (BiTree)malloc(sizeof(BiTNode));
        p->rchild = NULL;
        p->lchild = NULL;
        p->data = m;
        q = r;
        while(q)
        {
            if(m>q->data)
            {  w = q;
               q = q->rchild;
            }
            else if(m<=q->data)
            {  w = q;
               q = q->lchild;
            }
        }
        if(m>w->data)
            w->rchild = p;
        else
            w->lchild = p;
        return r; 
    }
BiTree InitBiTree()  //初始化头结点
{
    BiTree root;
    root = (BiTree)malloc(sizeof(BiTNode));
    root->lchild = NULL;
    root->rchild = NULL;
    return root;
 
}
void midPrint(BiTree root)//中序输出
{
    if(root)
    {
        midPrint(root->lchild);
        if(j==1){
            j++;
            printf("%d",root->data);
        }else
            printf(" %d",root->data);
        midPrint(root->rchild);
    }
}
int main()
{
     int m;
     scanf("%d",&m);
       BiTree root;
       int a[maxsize],i;
       j = 1;
       root = InitBiTree();
       scanf("%d",&root->data);
       for(i = 1;i<=m-1;i++)
       {
           scanf("%d",&a[i]);
           CreatBiTree(root,a[i]);
       }
            midPrint(root);
            printf("\n");
    return 0;
}