【树】树的广度遍历（1.打成一行 2.按层打成普通多行 3.按层打成之字形多行）

目录：

1.【树】二叉树的非递归遍历（栈&Morris）

2.【树】二叉树转为双向链表

3.【树】树的广度遍历（1.打成一行 2.按层打成普通多行 3.按层打成之字形多行）

1.从上往下打印二叉树：（一行）

打印结果：

a  b  c  d  e  f  g  h  i

vector<int> PrintFromTopToBottom(TreeNode *root) {
        vector<int> ans;
        if(root == NULL)
            return ans;
        queue<TreeNode*> nodes;
        nodes.push(root);
        
        while(!nodes.empty()) {
            TreeNode *curr = nodes.front();
            nodes.pop();
            ans.push_back(curr->val);
            if(curr->left)
                nodes.push(curr->left);
            if(curr->right)
                nodes.push(curr->right);
        }
        return ans;
    }

2.把二叉树打印成普通多行

打印结果：

a

b  c

d  e  f  g

h  i

思路：需要知道啥时候换行（所以1.两个变量 记录 当前层&下一层的节点数；2.队列 因为全都是从左向右打印）

vector<vector<int> > Print(TreeNode* pRoot) {
	vector<vector<int> > result;
    if(pRoot == NULL)
        return result;
            
    queue<TreeNode*> nodes;
	nodes.push(pRoot);
	vector<int> tmp;//记录每一层的答案，换层时需清空
	int nextLineNum = 0, currLineNum = 1;
            
	while(!nodes.empty()) {
                
		TreeNode* currNode = nodes.front();
		nodes.pop();
		tmp.push_back(currNode->val);
		currLineNum--;
                
		if(currNode->left) {
			nodes.push(currNode->left);
			nextLineNum++;
		}
		if(currNode->right) {
			nodes.push(currNode->right);
				nextLineNum++;
		}
                
		if(currLineNum == 0) {
			currLineNum = nextLineNum;
			nextLineNum = 0;
			result.push_back(tmp);
			while(!tmp.empty())
				tmp.pop_back();
		}
    }//while结束
    return result;
}

3.按之字形顺序打印二叉树

打印结果：

a

c  b

d  e  f  g

i  h

思路：

不仅需要知道啥时候换行，还需要知道 从左向右 还是 从右向左。所以：

1.用两个栈，根据层数判断：先压入右孩子还是左孩子

2.无需再像上题用两个变量记录节点数，直接用 两个栈都不empty()即可

vector<vector<int> > Print(TreeNode* pRoot) {
	vector<vector<int> > result;
	if(pRoot == NULL)
		return result;
        
	stack<TreeNode*> nodes[2];
	int level = 0;
	nodes[level].push(pRoot);
	vector<int> tmp;
        
	while(!nodes[0].empty() || !nodes[1].empty()) {
        TreeNode* currNode = nodes[level].top();
        nodes[level].pop();
        tmp.push_back(currNode->val);
         
        if(level == 0) {//先压入左孩子
            if(currNode->left) 
             	nodes[1 - level].push(currNode->left);

           	if(currNode->right) 
               	nodes[1 - level].push(currNode->right);
            }
        else {//先压入右孩子
           	if(currNode->right) 
               	nodes[1 - level].push(currNode->right);

            if(currNode->left) 
               	nodes[1 - level].push(currNode->left);
        }
            
        if(nodes[level].empty()) {//结束当前层
            result.push_back(tmp);
            while(!tmp.empty()) {
                tmp.pop_back();
            }

            level = 1 - level;
        }
    }//while结束
    return result; 
}