[LeetCode]Binary Tree Zigzag Level Order Traversal

最新推荐文章于 2021-02-05 11:10:39 发布

原创最新推荐文章于 2021-02-05 11:10:39 发布 · 700 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 专栏收录该内容

152 篇文章

订阅专栏

本文介绍了一种使用广度优先搜索(BFS)实现二叉树锯齿形层次遍历的方法。通过记录节点层级信息，该算法能够在遍历过程中区分不同层级，并按要求反转偶数层级的遍历结果。

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

class Solution {
	//BFS is always work for the level order traverse of a tree
	//all we need is add some additional information, to solve the specific problem of level order type
public:
	vector<vector<int>> LevelOrder_BFS(TreeNode* root)
	{
		vector<vector<int>> ans;
		if(!root)//put the null tree judge here will be more neet
			return ans;
		queue<pair<TreeNode*, int>> q;
		int stepNow = 0;
		q.push(make_pair(root, stepNow));
		vector<int> curLevel;
		while(!q.empty())
		{
			TreeNode* curNode = q.front().first;
			int curStep = q.front().second;
			q.pop();

			if(curStep != stepNow)
			{
				ans.push_back(curLevel);
				curLevel.clear();
				stepNow = curStep;
			}
			curLevel.push_back(curNode->val);
			if(curNode->left)
				q.push(make_pair(curNode->left, curStep+1));
			if(curNode->right)
				q.push(make_pair(curNode->right, curStep+1));

		}
		ans.push_back(curLevel);//note: we should remember the last level here
		//special process for zigzag order
		for(int i = 0; i < ans.size(); ++i)
		{
			if((i+1)%2 == 0)
				reverse(ans[i].begin(), ans[i].end());
		}
		return ans;
	}
	vector<vector<int> > zigzagLevelOrder(TreeNode *root) {
		// Start typing your C/C++ solution below
		// DO NOT write int main() function
		return LevelOrder_BFS(root);
	}
};

second time

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    struct Node
    {
        TreeNode* treeNode;
        int level;
        Node(TreeNode* _treeNode = NULL, int _level = 0):treeNode(_treeNode), level(_level){};
    };
    vector<vector<int> > zigzagLevelOrder(TreeNode *root) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if(root == NULL) return vector<vector<int> >();
        queue<Node> nodeQ;
        nodeQ.push(Node(root, 1));
        int prevLevel = 0;
        vector<int> curLevelAns;
        vector<vector<int> > allLevelAns;
        bool isForward = true;
        while(!nodeQ.empty())
        {
            TreeNode* curNode = nodeQ.front().treeNode;
            int curLevel = nodeQ.front().level;
            nodeQ.pop();
            if(curNode == NULL) continue;
            if(curLevel != prevLevel)
            {
                if(prevLevel != 0)
                {
                    if(!isForward) reverse(curLevelAns.begin(), curLevelAns.end());
                    allLevelAns.push_back(curLevelAns);
                    isForward = !isForward;
                }
                curLevelAns.clear();
            }
            prevLevel = curLevel;
            curLevelAns.push_back(curNode->val);
            nodeQ.push(Node(curNode->left, curLevel+1));
            nodeQ.push(Node(curNode->right, curLevel+1));
        }
        if(!isForward) reverse(curLevelAns.begin(), curLevelAns.end());
        allLevelAns.push_back(curLevelAns);
        
        return allLevelAns;
    }
};