二叉树的遍历(递归和非递归)

最新推荐文章于 2024-10-03 09:00:56 发布

weixin_34336526

最新推荐文章于 2024-10-03 09:00:56 发布

阅读量58

点赞数

文章标签： python 数据结构与算法

原文链接：https://my.oschina.net/lucusguo/blog/503536

版权

2019独角兽企业重金招聘Python工程师标准>>>

二叉树的定义

//Definition for a binary tree node
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL){}
};

先序遍历

 //递归方法
void preorder(TreeNode* root, vector<int>& path)
{
    if(root != NULL)
    {
        path.push_back(root->val);
        preorder(root->left, path);
        preorder(root->right, path);
    }
}
vector<int> preorderTraversal(TreeNode* root)
{
    vector<int> path;
    if(root == NULL)
    {
        return path;
    }
    preorder(root, path);
    return path;
}
//非递归方法
vector<int> preorderTraversal(TreeNode* root)
{
    vector<int> path;
    stack<TreeNode*> stk;
    if(root == NULL)
    {
        return path;
    }
    stk.push(root);
    while(!stk.empty())
    {
        TreeNode* tmp = stk.top();
        stk.pop();
        path.push_back(tmp->val);
        //先序遍历是 根节点->左节点->右节点  这里用的是栈，所以要先右  后左
        if(tmp->right != NULL)
        {
            stk.push(tmp->right);
        }
        if(tmp->left != NULL)
        {
            stk.push(tmp->left);
        }
    }
    return path;
}

中序遍历

//递归方法
void inorder(TreeNode* root, vector<int>& path)
{
    if(root != NULL)
    {
        inorder(root->left, path);
        path.push_back(root->val);
        inorder(root->right, path);
    }
}
vector<int> inorderTraversal(TreeNode* root)
{
    vector<int> path;
    if(root == NULL)
    {
        return path;
    }
    inorder(root, path);
    return path;
}
//非递归方法
vector<int> inorderTraversal(TreeNode* root)
{
    vector<int> path;
    stack<TreeNode*> stk;
    if(root == NULL)
    {
        return path;
    }
    TreeNode* p = root;
    while(!stk.empty() || p != NULL)
    {
        if(p != NULL)
        {
            stk.push(p);
            p = p->left;
        }
        else
        {
            p = stk.top();
            stk.pop();
            path.push_back(p->val);
            p = p->right;
        }
    }
    return path;
}

后续遍历

//递归方法
void postorder(TreeNode* root, vector<int>& path)
{
    if(root != NULL)
    {
        postorder(root->left, path);
        postorder(root->right, path);
        path.push_back(root->val);
    }
}
vector<int> postorderTraversal(TreeNode* root)
{
    vector<int> path;
    if(root == NULL)
    {
        return path;
    }
    postorder(root, path);
    return path;
}
//非递归方法
vector<int> postorderTraversal(TreeNode* root)
{
    vector<int> result;
    stack<TreeNode*> stk;
    TreeNode *current = root, *lastvisited = NULL;
    while(current != NULL || !stk.empty())
    {
        if(current != NULL)
        {
            stk.push(current);
            current = current->left;
        }
        else
        {
            if(stk.top()->right == lastvisited)
            {
                lastvisited = stk.top();
                result.push_back(lastvisited->val);
                stk.pop();
            }
            else
            {
                current = stk.top();
                current = current->right;
                lastvisited = NULL;
            }
        }
    }
    return result;
}

层次遍历

vector<vector<int>> levelOrder(TreeNode* root)
{
    vector<vector<int>> result;
    queue<TreeNode*> queue;
    if(root == NULL)
    {
        return result;
    }
    queue.push(root);
    while(!queue.empty())
    {
        vector<int> level;
        int size = queue.size();
        for(int i = 0; i < size; i++)
        {
            TreeNode* tmp = queue.front();
            level.push_back(tmp->val);
            queue.pop();
            if(tmp->left != NULL)
            {
                queue.push(tmp-left);
            }
            if(tmp->right != NULL)
            {
                queue.push(right);
            }
        }
        result.push_back(level);
    }
    return result;  
}

转载于:https://my.oschina.net/lucusguo/blog/503536