【剑指】32(1).不分行从上往下打印二叉树

题目描述

• 不分行从上往下打印出二叉树的每个结点，同一层的结点按照从左到右的顺序打印。

算法分析

• 广度优先遍历搜索问题，用一个队列保存将要搜索的这一层的元素，然后逐个搜索：1. 将第一个元素加入队列；2. 队列不为空时取队首元素；3. 将下一层元素加入队尾；4. 回到第二步，直到队列为空。

提交代码：

class Solution {
public:
	vector<int> PrintFromTopToBottom(TreeNode* root) {
		if (!root)
			return vector<int>();

		vector<int> result;
		queue<TreeNode*> treeQue;
		
		treeQue.push(root);

		while (!treeQue.empty())
		{
			TreeNode* node = treeQue.front();
			treeQue.pop();

			result.push_back(node->val);

			if (node->left) 
				treeQue.push(node->left);
			if (node->right) 
				treeQue.push(node->right);
		}

		return result;
	}
};

测试代码：

// ====================测试代码====================
void Test(char* testName, TreeNode* pRoot)
{
	if (testName != nullptr)
		printf("%s begins: \n", testName);

	PrintTree(pRoot);

	printf("The nodes from top to bottom, from left to right are: \n");
	Solution s;
	vector<int> result = s.PrintFromTopToBottom(pRoot);

	for (int each : result)
		cout << each << " ";
	cout << endl;
}

//            10
//         /      \
//        6        14
//       /\        /\
//      4  8     12  16
void Test1()
{
	TreeNode* pNode10 = CreateBinaryTreeNode(10);
	TreeNode* pNode6 = CreateBinaryTreeNode(6);
	TreeNode* pNode14 = CreateBinaryTreeNode(14);
	TreeNode* pNode4 = CreateBinaryTreeNode(4);
	TreeNode* pNode8 = CreateBinaryTreeNode(8);
	TreeNode* pNode12 = CreateBinaryTreeNode(12);
	TreeNode* pNode16 = CreateBinaryTreeNode(16);

	ConnectTreeNodes(pNode10, pNode6, pNode14);
	ConnectTreeNodes(pNode6, pNode4, pNode8);
	ConnectTreeNodes(pNode14, pNode12, pNode16);

	Test("Test1", pNode10);

	DestroyTree(pNode10);
}

//               5
//              /
//             4
//            /
//           3
//          /
//         2
//        /
//       1
void Test2()
{
	TreeNode* pNode5 = CreateBinaryTreeNode(5);
	TreeNode* pNode4 = CreateBinaryTreeNode(4);
	TreeNode* pNode3 = CreateBinaryTreeNode(3);
	TreeNode* pNode2 = CreateBinaryTreeNode(2);
	TreeNode* pNode1 = CreateBinaryTreeNode(1);

	ConnectTreeNodes(pNode5, pNode4, nullptr);
	ConnectTreeNodes(pNode4, pNode3, nullptr);
	ConnectTreeNodes(pNode3, pNode2, nullptr);
	ConnectTreeNodes(pNode2, pNode1, nullptr);

	Test("Test2", pNode5);

	DestroyTree(pNode5);
}

// 1
//  \
//   2
//    \
//     3
//      \
//       4
//        \
//         5
void Test3()
{
	TreeNode* pNode1 = CreateBinaryTreeNode(1);
	TreeNode* pNode2 = CreateBinaryTreeNode(2);
	TreeNode* pNode3 = CreateBinaryTreeNode(3);
	TreeNode* pNode4 = CreateBinaryTreeNode(4);
	TreeNode* pNode5 = CreateBinaryTreeNode(5);

	ConnectTreeNodes(pNode1, nullptr, pNode2);
	ConnectTreeNodes(pNode2, nullptr, pNode3);
	ConnectTreeNodes(pNode3, nullptr, pNode4);
	ConnectTreeNodes(pNode4, nullptr, pNode5);

	Test("Test3", pNode1);

	DestroyTree(pNode1);
}

// 树中只有1个结点
void Test4()
{
	TreeNode* pNode1 = CreateBinaryTreeNode(1);
	Test("Test4", pNode1);

	DestroyTree(pNode1);
}

// 树中没有结点
void Test5()
{
	Test("Test5", nullptr);
}

int main(int argc, char* argv[])
{
	Test1();
	Test2();
	Test3();
	Test4();
	Test5();

	return 0;
}