【剑指】32(2).分行从上到下打印二叉树

题目描述

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

算法分析

• 与32(1)基本相同，但需要考虑元素所处层的问题；原本使用了两个队列，其中一个用来保存元素所属的层数，经过修改发现可以不需要使用这个队列，节省了空间。

提交代码：

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

		vector<vector<int> > result;
		queue<TreeNode*> nodeQue;

		nodeQue.push(pRoot);

		while (!nodeQue.empty())
		{
			vector<int> temp;
			/* 当前层的结点数 */
			int elems = nodeQue.size();

			for (int i = 0; i < elems; ++i)
			{
				TreeNode* node = nodeQue.front();
				nodeQue.pop();

				temp.push_back(node->val);

				if (node->left)
					nodeQue.push(node->left);

				if (node->right)
					nodeQue.push(node->right);
			}
			result.push_back(temp);
		}

		return result;
	}
	/* 两个队列,其中一个保存所处层,比方法一多用了一个队列，空间复杂度增加 */
	vector<vector<int> > Print2(TreeNode* pRoot) {
		if (!pRoot)
			return vector<vector<int> >();

		vector<vector<int> > result;
		queue<int> layers;
		queue<TreeNode*> nodeQue;

		nodeQue.push(pRoot);
		layers.push(0);

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

			int layer = layers.front();
			layers.pop();

			if (result.size() <= layer)
			{
				vector<int> temp;
				temp.push_back(node->val);
				result.push_back(temp);
			}
			else
				result[layer].push_back(node->val);

			if (node->left)
			{
				nodeQue.push(node->left);
				layers.push(layer + 1);
			}

			if (node->right)
			{
				nodeQue.push(node->right);
				layers.push(layer + 1);
			}
		}

		return result;
	}

};

测试代码：

// ====================测试代码====================
//            8
//        6      10
//       5 7    9  11
void Test1()
{
	TreeNode* pNode8 = CreateBinaryTreeNode(8);
	TreeNode* pNode6 = CreateBinaryTreeNode(6);
	TreeNode* pNode10 = CreateBinaryTreeNode(10);
	TreeNode* pNode5 = CreateBinaryTreeNode(5);
	TreeNode* pNode7 = CreateBinaryTreeNode(7);
	TreeNode* pNode9 = CreateBinaryTreeNode(9);
	TreeNode* pNode11 = CreateBinaryTreeNode(11);

	ConnectTreeNodes(pNode8, pNode6, pNode10);
	ConnectTreeNodes(pNode6, pNode5, pNode7);
	ConnectTreeNodes(pNode10, pNode9, pNode11);

	printf("====Test1 Begins: ====\n");
	printf("Expected Result is:\n");
	printf("8 \n");
	printf("6 10 \n");
	printf("5 7 9 11 \n\n");

	printf("Actual Result is: \n");
	Solution s;
	vector<vector<int> > result = s.Print(pNode8);
	for (vector<int> temp : result)
	{
		for (int each : temp)
			cout << each << " ";
		cout << endl;
	}
	DestroyTree(pNode8);
}

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

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

	printf("====Test2 Begins: ====\n");
	printf("Expected Result is:\n");
	printf("5 \n");
	printf("4 \n");
	printf("3 \n");
	printf("2 \n\n");

	printf("Actual Result is: \n");
	Solution s;
	s.Print(pNode5);
	printf("\n");

	DestroyTree(pNode5);
}

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

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

	printf("====Test3 Begins: ====\n");
	printf("Expected Result is:\n");
	printf("5 \n");
	printf("4 \n");
	printf("3 \n");
	printf("2 \n\n");

	printf("Actual Result is: \n");
	Solution s;
	vector<vector<int> > result = s.Print(pNode5);
	for (vector<int> temp : result)
	{
		for (int each : temp)
			cout << each << " ";
		cout << endl;
	}

	DestroyTree(pNode5);
}

void Test4()
{
	TreeNode* pNode5 = CreateBinaryTreeNode(5);

	printf("====Test4 Begins: ====\n");
	printf("Expected Result is:\n");
	printf("5 \n\n");

	printf("Actual Result is: \n");
	Solution s;
	vector<vector<int> > result = s.Print(pNode5);
	for (vector<int> temp : result)
	{
		for (int each : temp)
			cout << each << " ";
		cout << endl;
	}

	DestroyTree(pNode5);
}

void Test5()
{
	printf("====Test5 Begins: ====\n");
	printf("Expected Result is:\n");

	printf("Actual Result is: \n");
	Solution s;
	vector<vector<int> > result = s.Print(nullptr);
	for (vector<int> temp : result)
	{
		for (int each : temp)
			cout << each << " ";
		cout << endl;
	}
}

//        100
//        /
//       50   
//         \
//         150
void Test6()
{
	TreeNode* pNode100 = CreateBinaryTreeNode(100);
	TreeNode* pNode50 = CreateBinaryTreeNode(50);
	TreeNode* pNode150 = CreateBinaryTreeNode(150);

	ConnectTreeNodes(pNode100, pNode50, nullptr);
	ConnectTreeNodes(pNode50, nullptr, pNode150);

	printf("====Test6 Begins: ====\n");
	printf("Expected Result is:\n");
	printf("100 \n");
	printf("50 \n");
	printf("150 \n\n");

	printf("Actual Result is: \n");
	Solution s;
	vector<vector<int> > result = s.Print(pNode100);
	for (vector<int> temp : result)
	{
		for (int each : temp)
			cout << each << " ";
		cout << endl;
	}
}

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

	return 0;
}