《剑指Offer——三种顺序打印二叉树》代码

Posted 2021-10-19 穿迷彩服的鲨鱼

三种顺序打印二叉树

• 前言
• 一、示例
• • 1.不分行从上往下打印二叉树
  • 2.分行从上到下打印二叉树
  • 3.之字形打印二叉树
• 二、代码解析
• • 1.新建.cpp文件
  • • 代码如下（示例）：

---

前言

//==================================================================
// 《剑指Offer——（一）：不分行从上往下打印二叉树》代码
// 《剑指Offer——（二）：分行从上到下打印二叉树》代码
// 《剑指Offer——（三）：之字形打印二叉树》代码
//==================================================================

---

一、示例

1.不分行从上往下打印二叉树

/*******************************************************************
从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。
例如:
给定二叉树: [3,9,20,null,null,15,7],

	3
   / \\
  9  20
	/  \\
   15   7
返回：
[3,9,20,15,7]
/*******************************************************************/

2.分行从上到下打印二叉树

/*******************************************************************
从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
例如:
给定二叉树: [3,9,20,null,null,15,7],

	3
   / \\
  9  20
	/  \\
   15   7
返回其层次遍历结果：
[
  [3],
  [9,20],
  [15,7]
]
/*******************************************************************/

3.之字形打印二叉树

/*******************************************************************
请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，
第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。
例如:
给定二叉树: [3,9,20,null,null,15,7],

	3
   / \\
  9  20
	/  \\
   15   7
返回其层次遍历结果：

[
  [3],
  [20,9],
  [15,7]
]
/*******************************************************************/

二、代码解析

1.新建.cpp文件

代码如下（示例）：

//==================================================================
// 《剑指Offer——（一）：不分行从上往下打印二叉树》代码
// 《剑指Offer——（二）：分行从上到下打印二叉树》代码
// 《剑指Offer——（三）：之字形打印二叉树》代码
//==================================================================

#include<iostream>
#include<vector>
#include<deque>
using namespace std;

struct TreeNode
{
	int val;
	TreeNode* left;
	TreeNode* right;
};
/*******************************************************************
从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。
例如:
给定二叉树: [3,9,20,null,null,15,7],

	3
   / \\
  9  20
	/  \\
   15   7
返回：
[3,9,20,15,7]
/*******************************************************************/
vector<int> levelOrder1(TreeNode* root)
{
	vector<int> nums;
	if (root == nullptr)
	{
		return nums;
	}

	deque<TreeNode*> dequeTreeNode;
	dequeTreeNode.push_back(root);

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

		nums.push_back(pNode->val);

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

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

	return nums;
}
/*******************************************************************
从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
例如:
给定二叉树: [3,9,20,null,null,15,7],

	3
   / \\
  9  20
	/  \\
   15   7
返回其层次遍历结果：
[
  [3],
  [9,20],
  [15,7]
]
/*******************************************************************/
vector<vector<int>> levelOrder2(TreeNode* root)
{
	vector<vector<int>> Nums;
	vector<int> nums;
	if (root == nullptr)
	{
		return Nums;
	}

	deque<TreeNode*> dequeTreeNode;
	dequeTreeNode.push_back(root);

	int nextLevel = 0;
	int toBePrinted = 1;

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

		nums.push_back(pNode->val);

		if (pNode->left)
		{
			dequeTreeNode.push_back(pNode->left);
			++nextLevel;
		}

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

		--toBePrinted;
		if (toBePrinted == 0)
		{
			Nums.push_back(nums);
			nums.clear();
			toBePrinted = nextLevel;
			nextLevel = 0;
		}
	}

	return Nums;
}
/*******************************************************************
请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，
第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。
例如:
给定二叉树: [3,9,20,null,null,15,7],

	3
   / \\
  9  20
	/  \\
   15   7
返回其层次遍历结果：

[
  [3],
  [20,9],
  [15,7]
]
/*******************************************************************/
vector<vector<int>> levelOrder3(TreeNode* root)
{
	vector<vector<int>> Nums;
	vector<int> nums;
	if (root == nullptr)
	{
		return Nums;
	}

	deque<TreeNode*> dequeTreeNode;
	dequeTreeNode.push_back(root);

	int nextLevel = 0;
	int toBePrinted = 1;

	int rTO = 0;

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

		nums.push_back(pNode->val);

		if (pNode->left)
		{
			dequeTreeNode.push_back(pNode->left);
			++nextLevel;
		}

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

		--toBePrinted;
		if (toBePrinted == 0)
		{
			if (rTO==0)
			{
				Nums.push_back(nums);
				rTO = 1;
			}
			else
			{
				Nums.push_back(ReverseOrder(nums));
				rTO = 0;
			}
			nums.clear();
			toBePrinted = nextLevel;
			nextLevel = 0;
		}
	}

	return Nums;
}
/*反转数组*/
vector<int> ReverseOrder(vector<int>& nums)
{
	int len = nums.size();
	for (int i = 0; i < len/2; ++i)
	{
		int temp = nums[i];
		nums[i] = nums[len - i-1];
		nums[len - i - 1] = temp;
	}
	return nums;
}

int main()
{
	
	return 0;
}