《剑指offer》77--按之字形顺序打印二叉树[C++][Java]

贫道绝缘子

于 2021-12-31 15:34:58 发布

阅读量112

点赞数

分类专栏：剑指offer 文章标签：算法蓝桥杯 c++

本文链接：https://blog.csdn.net/qq_15711195/article/details/122255990

版权

剑指offer 专栏收录该内容

82 篇文章 1 订阅

订阅专栏

这篇博客介绍了如何用C++和Java实现之字形打印二叉树的方法，包括双端队列和双栈两种解法。解题思路中详细展示了每种方法的代码实现，通过维护两个容器（队列或栈），交替从左右方向遍历节点，从而达到按之字形打印的效果。

摘要由CSDN通过智能技术生成

题目描述

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

解题思路

【C++解法】

1、双端队列

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector< vector<int>> res;
        deque<TreeNode*> q;
        if(pRoot) q.push_back(pRoot);
        bool flag = true;
        while(!q.empty()) {
            int len = q.size();
            vector<int> tmp;
            if(flag) {
                while(len--) {
                    TreeNode* p = q.front(); q.pop_front();
                    if(p->left) q.push_back(p->left);
                    if(p->right) q.push_back(p->right);
                    tmp.push_back(p->val);
                }
            } else {
                while(len--) {
                    TreeNode* p = q.back(); q.pop_back();
                    if(p->right) q.push_front(p->right);
                    if(p->left) q.push_front(p->left);
                    tmp.push_back(p->val);
                }
            }
            flag = !flag;
            res.push_back(tmp);
        }
        return res;
    }
};

2、双栈

class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector< vector<int>> res;
        stack<TreeNode*> q[2];
        if(pRoot) q[0].push(pRoot);
        bool flag = true;
        while(!q[0].empty() || !q[1].empty()) {
            vector<int> tmp;
            if(flag) {
                while(!q[0].empty()) {
                    TreeNode* p = q[0].top(); q[0].pop();
                    if(p->left) q[1].push(p->left);
                    if(p->right) q[1].push(p->right);
                    tmp.push_back(p->val);
                }
            } else {
                while(!q[1].empty()) {
                    TreeNode* p = q[1].top(); q[1].pop();
                    if(p->right) q[0].push(p->right);
                    if(p->left) q[0].push(p->left);
                    tmp.push_back(p->val);
                }
            }
            flag = !flag;
            res.push_back(tmp);
        }
        return res;
    }
};

【Java解法】

import java.util.ArrayList;
import java.util.Stack;
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer> > res = new ArrayList<ArrayList<Integer> >();
        Stack<TreeNode> s1 = new Stack<>();
        Stack<TreeNode> s2 = new Stack<>();
        if (pRoot != null) { s1.push(pRoot);}
        while (!s1.empty() || !s2.empty()) {
            ArrayList<Integer> tmp = new ArrayList<>();
            if (!s1.empty()) {
                while (!s1.empty()) {
                    TreeNode p = s1.pop();
                    tmp.add(p.val);
                    if (p.left != null) {s2.push(p.left);}
                    if (p.right != null) {s2.push(p.right);}
                }
            } else {
                while (!s2.empty()) {
                    TreeNode p = s2.pop();
                    tmp.add(p.val);
                    if (p.right != null) {s1.push(p.right);}
                    if (p.left != null) {s1.push(p.left);}
                }
            }
            res.add(tmp);
        }
        return res;
    }

}