剑指Offer----面试题23：从上往下打印二叉树(层序遍历)

最新推荐文章于 2019-08-02 18:07:15 发布

烽火前秦路

最新推荐文章于 2019-08-02 18:07:15 发布

阅读量460

点赞数

分类专栏：剑指Offer 文章标签： C++ 剑指offer 面试题二叉树

本文链接：https://blog.csdn.net/qianqin_2014/article/details/51589376

版权

剑指Offer 专栏收录该内容

81 篇文章 2 订阅

订阅专栏

题目：

从上往下打印出二叉树的每个结点，同一层的结点按照从左到右的顺序打印。如下图的二叉树，则依次打印出8,6,10,5,7,9,11.

分析：

源代码：

#include"BinaryTree.h"
#include<iostream>
#include<queue>

using std::cout;
using std::endl;
using std::queue;

using namespace OrdinaryBinaryTreeSpace4;

void PrintTreeFromTopToBottom(BinaryTreeNode *root)
{
	if (root == NULL)
	{ 
		cout << "The tree is empty" << endl;
		return;
	}

	queue<BinaryTreeNode *> myQueue;
	myQueue.push(root);

	while (!myQueue.empty())
	{
		BinaryTreeNode *temp = myQueue.front();
		myQueue.pop();
		cout << temp->element << "  ";
		if (temp->left != NULL)
			myQueue.push(temp->left);
		if (temp->right != NULL)
			myQueue.push(temp->right);
	}
}

void test11()
{
	cout << "\t=======从上往下打印满二叉树" << endl;
	BinaryTreeNode *node1 = CreateBinaryTreeNode(8);
	BinaryTreeNode *node2 = CreateBinaryTreeNode(6);
	BinaryTreeNode *node3 = CreateBinaryTreeNode(10);
	BinaryTreeNode *node4 = CreateBinaryTreeNode(5);
	BinaryTreeNode *node5 = CreateBinaryTreeNode(7);
	BinaryTreeNode *node6 = CreateBinaryTreeNode(9);
	BinaryTreeNode *node7 = CreateBinaryTreeNode(11);

	ConnectBinaryTreeNodes(node1, node2, node3);
	ConnectBinaryTreeNodes(node2, node4, node5);
	ConnectBinaryTreeNodes(node3, node6, node7);
	ConnectBinaryTreeNodes(node4, NULL, NULL);
	ConnectBinaryTreeNodes(node5, NULL, NULL);
	ConnectBinaryTreeNodes(node6, NULL, NULL);
	ConnectBinaryTreeNodes(node7, NULL, NULL);

	PrintTreeFromTopToBottom(node1);

	DestoryTree(node1);
}

void test12()
{
	cout << "\t=======从上往下打印空二叉树" << endl;

	PrintTreeFromTopToBottom(NULL);
}

/*
					1
				   / \
				  2   3
				     / \
					4   5
				   /
				  6
*/
void test13()
{
	cout << "\t=======从上往下打印不完全二叉树" << endl;
	BinaryTreeNode *node1 = CreateBinaryTreeNode(1);
	BinaryTreeNode *node2 = CreateBinaryTreeNode(2);
	BinaryTreeNode *node3 = CreateBinaryTreeNode(3);
	BinaryTreeNode *node4 = CreateBinaryTreeNode(4);
	BinaryTreeNode *node5 = CreateBinaryTreeNode(5);
	BinaryTreeNode *node6 = CreateBinaryTreeNode(6);

	ConnectBinaryTreeNodes(node1, node2, node3);
	ConnectBinaryTreeNodes(node2, NULL, NULL);
	ConnectBinaryTreeNodes(node3, node4, node5);
	ConnectBinaryTreeNodes(node4, node6, NULL);
	ConnectBinaryTreeNodes(node5, NULL, NULL);
	ConnectBinaryTreeNodes(node6, NULL, NULL);

	PrintTreeFromTopToBottom(node1);

	DestoryTree(node1);
}


/*
						1
					   /
					  2
					 /
					3
				   /
				  4
				 /
				5
			   /
			  6
			 /
			7
*/
void test14()
{
	cout << "\t=======从上往下打印只有左孩子的二叉树" << endl;
	BinaryTreeNode *node1 = CreateBinaryTreeNode(1);
	BinaryTreeNode *node2 = CreateBinaryTreeNode(2);
	BinaryTreeNode *node3 = CreateBinaryTreeNode(3);
	BinaryTreeNode *node4 = CreateBinaryTreeNode(4);
	BinaryTreeNode *node5 = CreateBinaryTreeNode(5);
	BinaryTreeNode *node6 = CreateBinaryTreeNode(6);
	BinaryTreeNode *node7 = CreateBinaryTreeNode(7);

	ConnectBinaryTreeNodes(node1, node2, NULL);
	ConnectBinaryTreeNodes(node2, node3, NULL);
	ConnectBinaryTreeNodes(node3, node4, NULL);
	ConnectBinaryTreeNodes(node4, node5, NULL);
	ConnectBinaryTreeNodes(node5, node6, NULL);
	ConnectBinaryTreeNodes(node6, node7, NULL);
	ConnectBinaryTreeNodes(node7, NULL, NULL);

	PrintTreeFromTopToBottom(node1);

	DestoryTree(node1);
}

void test15()
{
	cout << "\t=======从上往下打印只有右孩子的二叉树" << endl;
	BinaryTreeNode *node1 = CreateBinaryTreeNode(1);
	BinaryTreeNode *node2 = CreateBinaryTreeNode(2);
	BinaryTreeNode *node3 = CreateBinaryTreeNode(3);
	BinaryTreeNode *node4 = CreateBinaryTreeNode(4);
	BinaryTreeNode *node5 = CreateBinaryTreeNode(5);
	BinaryTreeNode *node6 = CreateBinaryTreeNode(6);
	BinaryTreeNode *node7 = CreateBinaryTreeNode(7);

	ConnectBinaryTreeNodes(node1, NULL, node2);
	ConnectBinaryTreeNodes(node2, NULL, node3);
	ConnectBinaryTreeNodes(node3, NULL, node4);
	ConnectBinaryTreeNodes(node4, NULL, node5);
	ConnectBinaryTreeNodes(node5, NULL, node6);
	ConnectBinaryTreeNodes(node6, NULL, node7);
	ConnectBinaryTreeNodes(node7, NULL, NULL);

	PrintTreeFromTopToBottom(node1);

	DestoryTree(node1);
}

int main()
{
	test11();
	cout << endl;

	test12();
	cout << endl;

	test13();
	cout << endl;

	test14();
	cout << endl;

	test15();
	cout << endl;

	system("pause");
	return 0;
}

运行结果：

        =======从上往下打印满二叉树
8  6  10  5  7  9  11
        =======从上往下打印空二叉树
The tree is empty

        =======从上往下打印不完全二叉树
1  2  3  4  5  6
        =======从上往下打印只有左孩子的二叉树
1  2  3  4  5  6  7
        =======从上往下打印只有右孩子的二叉树
1  2  3  4  5  6  7
请按任意键继续. . .

官方源代码：

#include"BinaryTree.h"
#include<cstdlib>
#include<cstdio>
#include<deque>

using namespace OrdinaryBinaryTreeSpace4;

void PrintFromTopToBottom(BinaryTreeNode* pRoot)
{
	if (pRoot == NULL)
		return;

	std::deque<BinaryTreeNode *> dequeTreeNode;

	dequeTreeNode.push_back(pRoot);

	while (dequeTreeNode.size())
	{
		BinaryTreeNode *pNode = dequeTreeNode.front();
		dequeTreeNode.pop_front();

		printf("%d ", pNode->element);

		if (pNode->left)
			dequeTreeNode.push_back(pNode->left);

		if (pNode->right)
			dequeTreeNode.push_back(pNode->right);
	}
}

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

	PrintTreePre(pRoot);

	printf("The nodes from top to bottom, from left to right are: \n");
	PrintFromTopToBottom(pRoot);

	printf("\n\n");
}

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

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

	Test("Test1", pNode10);

	DestoryTree(pNode10);
}

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

	ConnectBinaryTreeNodes(pNode5, pNode4, NULL);
	ConnectBinaryTreeNodes(pNode4, pNode3, NULL);
	ConnectBinaryTreeNodes(pNode3, pNode2, NULL);
	ConnectBinaryTreeNodes(pNode2, pNode1, NULL);

	Test("Test2", pNode5);

	DestoryTree(pNode5);
}

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

	ConnectBinaryTreeNodes(pNode1, NULL, pNode2);
	ConnectBinaryTreeNodes(pNode2, NULL, pNode3);
	ConnectBinaryTreeNodes(pNode3, NULL, pNode4);
	ConnectBinaryTreeNodes(pNode4, NULL, pNode5);

	Test("Test3", pNode1);

	DestoryTree(pNode1);
}

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

	DestoryTree(pNode1);
}

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

int main()
{
	Test1();
	Test2();
	Test3();
	Test4();
	Test5();

	system("pause");
	return 0;
}

运行结果：

Test1 begins:
10  6  4  8  14  12  16  The nodes from top to bottom, from left to right are
10 6 14 4 8 12 16

Test2 begins:
5  4  3  2  1  The nodes from top to bottom, from left to right are:
5 4 3 2 1

Test3 begins:
1  2  3  4  5  The nodes from top to bottom, from left to right are:
1 2 3 4 5

Test4 begins:
1  The nodes from top to bottom, from left to right are:
1

Test5 begins:
The tree is empty
The nodes from top to bottom, from left to right are:


请按任意键继续. . .

烽火前秦路

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
剑指Offer----面试题23：从上往下打印二叉树(层序遍历)

题目：从上往下打印出二叉树的每个结点，同一层的结点按照从左到右的顺序打印。如下图的二叉树，则依次打印出8,6,10,5,7,9,11.分析：源代码：#include"BinaryTree.h"#include#includeusing std::cout;using std::endl;using std::queue;
复制链接

扫一扫