二叉搜索树的前序、中序、层次、后序遍历

最新推荐文章于 2021-01-23 10:32:35 发布

原创最新推荐文章于 2021-01-23 10:32:35 发布 · 575 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#二叉树 #递归法 #栈 #dfs #bfs

C/C++ 同时被 3 个专栏收录

4 篇文章

订阅专栏

面试题总结

2 篇文章

订阅专栏

算法

2 篇文章

订阅专栏

本文深入探讨二叉树的前序、中序、后序及层次遍历算法，包括递归与迭代实现，适用于算法学习与面试准备。

一、二叉树的前序遍历

Leetcode-144：二叉树的前序遍历

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

递归大法：

vector<int> res;
vector<int> preorderTraversal(TreeNode* root) {
    if(root == NULL){
        return res;
    }
    //将根节点的值保存在数组中，然后递归处理左子树和右子树
    res.push_back(root->val);
    preorderTraversal(root->left);
    preorderTraversal(root->right);
    return res;
}

迭代大法：

思路：

从根结点开始遍历，遇到不为空的节点，就将节点值放入数组，并将节点保存在栈中（方便后续遍历其右子树）。
当遇到空节点时，从栈里面取出一个节点，然后开始遍历其右子树。
每个节点访问两次，第一次先入栈并加入结果数组，然后处理其左子树，第二次出栈，然后处理其右子树。

vector<int> preorderTraversal(TreeNode* root) {
    vector<int> res;
    stack<TreeNode*> myStack;
    TreeNode* curNode = root;
    while(curNode != NULL || myStack.size() > 0){
        //1、第一次先入栈，并加入结果数组，然后处理其左子树
        while(curNode != NULL){
            myStack.push(curNode);
            res.push_back(curNode->val);
            curNode = curNode->left;
        }
        //2、第二次出栈，然后处理其右子树
        TreeNode* node = myStack.top();
        myStack.pop();
        curNode = node->right;
    }
    return res;
}

二、二叉树的中序遍历

Leetcode-94：二叉树的中序遍历

递归大法：

vector<int> res;
vector<int> inorderTraversal(TreeNode* root) {
    if(root == NULL){
        return res;
    }
    //先处理左子树，然后根节点，最后处理右子树
    inorderTraversal(root->left);
    res.push_back(root->val);
    inorderTraversal(root->right);
    return res;
}

迭代大法：

思路：

从根节点开始遍历，一直寻找其左子节点，直到左子节点为空之前，将所有节点入栈。
取栈顶元素加入数组，然后迭代处理栈顶元素的右子树。
每个节点访问两次，第一次先入栈，然后处理其左子树，第二次出栈并加入结果数组，然后处理其右子树。

vector<int> inorderTraversal(TreeNode* root) {
    vector<int> res;
    stack<TreeNode*> myStack;
    TreeNode* curNode = root;
    while(curNode != NULL || myStack.size() > 0){
        //1、第一次先入栈，然后处理其左子树
        while(curNode != NULL){
            myStack.push(curNode);
            curNode = curNode->left;
        }
        //2、第二次先出栈，并加入结果数组，然后处理其右子树
        TreeNode* node = myStack.top();
        myStack.pop();
        res.push_back(node->val);
        curNode = node->right;
    }
    return res;
}

三、二叉树的层次遍历

Leetcode-103：二叉树的层次遍历

DFS：深度优先大法：

vector<vector<int>> res;
int levelNum = 0;
vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
    add2Vector(root, 0);
    for(int i = 1; i < levelNum; i=i+2){
        reverse(res[i].begin(), res[i].end());
    }
    return res;
}
//递归函数每次向下处理一层，将对应层的节点值放入到结果数组中对应下标的数组里面
void add2Vector(TreeNode* root, int level){
    levelNum = max(levelNum, level);
    if(root == NULL){
        return;
    }
    //level层数实际上比数组的值要大1，处理第0层的时候数组里面只保存2个元素，处理第1层的时候，数组里面要保存2个元素
    if(res.size() == level){
        res.resize(res.size() + 1);
    }
    //注意一定是根据层数作为数组的下标来进行往结果数组里面赋值
    res[level].push_back(root->val);
    add2Vector(root->left, level+1);
    add2Vector(root->right, level+1);
}

BFS：广度优先大法（使用2个栈解决）

vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
    vector<vector<int>> res;
    //1、异常情况处理
    if(root == NULL){
        return res;
    }
    //2/定义两个栈和保存每个数组元素的vec
    vector<int> vec;
    stack<TreeNode*> myStack1;
    stack<TreeNode*> myStack2;
    myStack1.push(root);
    //3、初始将root放入myStack1，然后开始遍历myStack1，也就是处理树的第一层（奇数层），处理的顺序是先左子树，后右子树，处理的同时将第一层的左子树和右子树都放入myStack2
    while(!myStack1.empty() || !myStack2.empty()){
        vec.clear();
        while(!myStack1.empty()){
            TreeNode* node = myStack1.top();
            myStack1.pop();
            vec.push_back(node->val);
            if(node->left != NULL){
                myStack2.push(node->left);
            }
            if(node->right != NULL){
                myStack2.push(node->right);
            }
        }
        //奇数层处理完了之后把结果放入res中，并清空vec
        if(vec.size() > 0){
            res.push_back(vec);
            vec.clear();
        }
        //然后开始处理偶数层的节点（由于在放入myStack2中节点的时候是先左后右，所以处理的时候是先右后左，满足偶数层的结果逆序），在处理偶数层的节点的同时需要把其左右子树加入到myStack1中（此前myStack1已经处理完了，为空），注意需要先放右子树，再放左子树，这样在处理myStack1的时候就会按照先左子树，后右子树的顺序处理了
        while(!myStack2.empty()){
            TreeNode* node = myStack2.top();
            myStack2.pop();
            vec.push_back(node->val);
            if(node->right != NULL){
                myStack1.push(node->right);
            }
            if(node->left != NULL){
                myStack1.push(node->left);
            }
        }
        //偶数层处理完了之后把结果放入res中，并清空vec
        if(vec.size() > 0){
            res.push_back(vec);
            vec.clear();
        }
    }
    return res;
}

四、二叉树的后序遍历

Leetcode-145：二叉树的后序遍历

递归大法：

vector<int> res;
vector<int> postorderTraversal(TreeNode* root) {
    if(root == NULL){
        return res;
    }
    //先左子树，后右子树，最后根节点
    postorderTraversal(root->left);
    postorderTraversal(root->right);
    res.push_back(root->val);
    return res;
}

迭代大法：

思路：

每个节点需要访问三次。
第一次先入栈然后处理其左子树。
第二次先出栈后入栈然后处理其右子树。
第三次将其值加入结果数组。
需要给每个节点新增一个flag记录访问的次数。

struct newTreeNode {
     TreeNode* node;
     int flag;
 };

vector<int> postorderTraversal(TreeNode* root) {
    vector<int> res;
    if(root == NULL){
        return res;
    }
    stack<newTreeNode*> myStack;
    TreeNode* curNode = root;
    while(curNode != NULL || !myStack.empty()){
        while(curNode != NULL){
            //1、第一次先将节点入栈，并循环处理其左子节点
            newTreeNode* p = new newTreeNode();
            p->node = curNode;
            p->flag = 1;
            myStack.push(p);
            curNode = curNode->left;
        }
        //2、第二次先出栈，然后入栈，并处理其右子树
        newTreeNode* newNode = myStack.top();
        myStack.pop();
        if(newNode->flag == 1){
            newNode->flag = 2;
            myStack.push(newNode);
            curNode = newNode->node->right;
        }else{
            //3、第三次出栈，并加入结果数组
            res.push_back(newNode->node->val);
        }
    }
    return res;
}

总结一下：递归大法真的香。