二叉树举例

二叉树举例说明

二叉树的定义，构造与遍历

树 是n(n>=0)个节点的 有限集 ，且这些节点 满足 如下关系:
(1)有且仅有一个节点没有父结点，该节点称为树的 根 。
(2)除根外，其余的每个节点都有且仅有一个 父结点 。
(3)树中的每一个节点都构成一个 以它为根 的树。
二叉树 在满足树的条件时，满足如下条件:
每个节点最多有 两个孩子 (子树)，这两个子树有 左右之分 ，次序不可颠倒。

构造二叉树：

/*对于二叉树的构造来书，主要是要定义结构体，并声明节点之间的逻辑关系*/
**/*接下来的所有树的节点都由这个结构体定义*/**
struct TreeNode
{
	int val;//节点值
	TreeNode *left;//节点的左子节点
	TreeNode *right;//节点的右子节点
	TreeNode(int x) :val(x), left(NULL), right(NULL) {}//构造函数，使用初始化列表进行初始化
};

int main() {
	/*定义树的逻辑关系*/
	TreeNode a(1);
	TreeNode b(2);
	TreeNode c(5);
	TreeNode d(3);
	TreeNode e(4);
	TreeNode f(6);
	a.left = &b;
	a.right = &c;
	b.left = &d;
	b.right = &e;
	c.right = &f;
	return 0;
}

遍历二叉树：

void traversal(TreeNode*node) {
	if (!node) {
		return;
	}
	//此时访问node称为前序遍历
	traversal(node->left);
	//此时访问node称为中序遍历
	traversal(node->right);
	//此时访问node称为前序遍历
}

例1：路径之和为sum的所有路径

给定一个 二叉树 与整数sum，找出 所有 从根节点到叶结点的 路径 ，这些路径上的节点值 累加和为sum 。树节点的定义按照构造树时的定义。

分析：
根据题意，我们可以知道，必须是从根节点到叶节点的路径，所以肯定是要遍历树的，那么就存在3个问题：
1.使用何种数据结构存储 遍历路径 上的节点？
2.在树的 前序遍历 时做什么? 后序遍历 时做什么?
3.如何判断一个节点为 叶结点 ?当遍历到叶结点时应该做什么?
对于存储树的节点值来书，栈的数据结构是最适合的，我们使用vector来表达栈的作用
1.从根节点 深度遍历 二叉树， 前序遍历 时，将该节点值存储至 path栈 栈 中(vector实现)，使用 path_value 累加 节点值。
2.当遍历至 叶结点 时，检查 path_value值 值 是否为sum，若为sum，则将path_push进入 result结果中。
3.在 后续遍历 时，将该节点值从path栈中 弹出 ，path_value 减去 节点值。

示例代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        vector<vector<int>> result;//存储满足条件的数组
        vector<int>path;//存储路径的栈
        int path_value=0;//路径的值
        preorder(root,path_value,sum,path,result);
        return result;
    }
    
    void preorder(TreeNode*node,int &path_value,
                  int sum,vector<int>&path,vector<vector<int>>&result){
        if(!node){//递归终止条件
            return;
        }
        path_value+=node->val;//在前序的时候进行累加路径值
        path.push_back(node->val);//节点入栈
        if(path_value==sum&&!node->left&&!node->right){//满足路径值和等于指定之时且当前节点为叶节点的时候满足条件。
            result.push_back(path);
        }
        preorder(node->left,path_value,sum,path,result);
        preorder(node->right,path_value,sum,path,result);
        path_value-=(node->val);//在后序遍历的时候进行减小路径值
        path.pop_back();//并出栈
    }
};

例2：最近的公共祖先（节点）

已知二叉树，求二叉树中给定的两个节点的 最近公共祖先 。最近公共祖先: 两节点v与w的最近公共祖先u，满足在 树上最低( 离根最远) ，且v,w两个节点都是u的 子孙 。如下图所示：红色节点是蓝色节点的公共祖先。

分析：
1.两个节点的 公共祖先 一定在从根节点，至这两个节点的路径上。
2.由于求公共祖先中的 最近 公共祖先，那么即 同时出现 在这两条路径上的 离根节点最远 的节点(或离两个最近)。
3.最终算法即:求p节点路径，q节点路径，两路径上 最后一个相同的节点。
那么现在的问题就转化为了求根节点至某节点路径（深度搜索）。现在采用遍历的方法进行搜索路径：
示例代码：

void preorder(TreeNode*node,TreeNode*search1,TreeNode*search2,vector<TreeNode*>&path,vector<vector<TreeNode*>>&result,int&finish) 
{
	if (!node||finish>=2)//当node为空或已找到search1节点和search2节点（finish==2）直接返回，结束搜索
	{
		return;
	}
	path.push_back(node);//前序遍历，将节点压入path的模拟栈中
	if (node==search1||node==search2)
	{
		++finish;//找到之后就将finish+1
		result.push_back(path);//并将path存储起来
	}
	preorder(node->left, search1, search2, path, result, finish);
	preorder(node->right, search1, search2, path, result, finish);
	path.pop_back();//遍历结束了就将node弹出
	/*最后result中就是存储的两条路径*/
}

在找到根节点到目标节点之后，现在只需要求出两路径上最后一个相同的节点
示例代码：

TreeNode* getComNode(vector<vector<TreeNode*>>result) {
	if (result.size()!=2)
	{
		return nullptr;
	}
	int min_length;
	TreeNode*comNode=nullptr;
	if (result[0].size()<result[1].size())
	{
		min_length = result[0].size();
	}
	else {
		min_length = result[1].size();
	}
	for (int  i = 0; i < min_length; i++)
	{
		if (result[0][i]==result[1][i])
		{
			comNode = result[0][i];
		}
		else
		{
			break;
		}
	}
	return comNode;
}

结合上述思路，整体的示例代码：

class Solution {
public:
	TreeNode *lowestCommonAncestor(TreeNode*root, TreeNode*p, TreeNode*q) {
		vector<TreeNode*>path;
		vector<vector<TreeNode*>>result;
		int finish = 0;
		preorder(root, p, q, path, result, finish);
		return getComNode(result);
	}

	void preorder(TreeNode*node, TreeNode*search1, TreeNode*search2, vector<TreeNode*>&path, vector<vector<TreeNode*>>&result, int&finish) {
		if (!node || finish >= 2)
		{
			return;
		}
		path.push_back(node);
		if (node == search1 || node == search2)
		{
			++finish;
			result.push_back(path);
		}
		preorder(node->left, search1, search2, path, result, finish);
		preorder(node->right, search1, search2, path, result, finish);
		path.pop_back();
	}

	TreeNode* getComNode(vector<vector<TreeNode*>>result) {
		if (result.size() != 2)
		{
			return nullptr;
		}
		int min_length;
		TreeNode*comNode = nullptr;
		if (result[0].size() < result[1].size())
		{
			min_length = result[0].size();
		}
		else {
			min_length = result[1].size();
		}
		for (int i = 0; i < min_length; i++)
		{
			if (result[0][i] == result[1][i])
			{
				comNode = result[0][i];
			}
			else
			{
				break;
			}
		}
		return comNode;
	}
};

例3： 二叉树转链表

给定一个 二叉树 ，将该二叉树 就地(in-place) 转换为 单链表 。单链表中节点顺序为二叉树 前序遍历 顺序。

分析：
1.如果在忽略就地转换的条件的话，可以直接前序遍历二叉树，将遍历结果存储到vector中，再使用vector中的数据构造链表。

示例代码：

class Solution {
public:
	void  flatten(TreeNode*root) {
		vector<TreeNode*>node_vec;//使用了vector来存储遍历的链表
		preorder(root,node_vec);
		for (int i = 1; i < node_vec.size(); i++)
		{
			node_vec[i - 1]->left = NULL;
			node_vec[i - 1]->right = node_vec[i];
		}
	}
	void preorder(TreeNode*node, vector<TreeNode*>&node_vec) {
		if (!node)
		{
			return;
		}
		node_vec.push_back(node);
		preorder(node->left, node_vec);
		preorder(node->right, node_vec);
	}
};

2.如果在不使用外部存储区的情况下，就要将每个节点的左右结点进行拆分

class Solution {
public:
	void  flatten(TreeNode*root) {
		TreeNode*last = NULL;
		preorder(root, last);
	}
	void preorder(TreeNode*node/*当前节点*/, TreeNode*&last/*当前子树的前序遍历的最后一个节点*/) {
		if (!node)
		{
			return;
		}
		if (!node->left && !node->right) {
			last = node;
			return;
		}
		TreeNode*left = node->left;//备份左指针
		TreeNode*right = node->right;//备份右指针
		TreeNode*left_last = NULL;//左右子树的最后一个节点
		TreeNode*right_last = NULL;
		if (left) {
			preorder(left, left_last);//若有左子树，递归将左子树转换单链表
			node->left = NULL;//左指针赋空
			node->right = left;
			last = left_last;//将该节点的last保存为左子树的last
		}if (right) {//若有右子树，递归将右子树转换为单链表
			preorder(right, right_last);//若node找到左子树最后一个节点
			if (left_last) {
				left_last->right = right;
			}
			last = right_last;
		}
	}
};

例4：二叉树的层序遍历

二叉树 层次遍历 ，又称为 宽度优先搜索 ，按树的层次依次访问树的结点。层次遍历使用 队列 对遍历节点进行 存储 ，先进入队列的结点， 优先遍历 拓展其左孩子与右孩子。
遍历算法与图例：

示例代码：

void BFS_print(TreeNode*root) {
	queue<TreeNode*>que;//设置队列，存储遍历的节点
	que.push(root);
	while (!que.empty())
	{
		TreeNode*pNode = que.front();
		que.pop();
		printf("%d", pNode->val);
		if (pNode->left) {
			que.push(pNode->left);
		}
		if (pNode->right) {
			que.push(pNode->right);
		}
	}
}

例5：侧面观察二叉树

给定一个 二叉树 ，假设从该二叉树的 右侧 观察它，将观察到的节点按照 从上到下 的顺序输出。

分析：
从二叉树的 右侧 观察它，将观察到的节点按照 从上到下 的顺序输出，就是求 层次遍历二叉树 ，每个层中的 最后一个节点 。
那么现在的问题就是怎么层序遍历并记录每层的最后一个节点？

解决思路：
层次遍历 时，将 节点与层数 绑定为pair，压入队列时，将节点与层数 同时 压入队列，并记录每一层中出现的 最后一个节点 。
在 层次遍历 中，每一层中的 最后一个节点最后遍历到 ， 随时更新 对每层的最后一个节点即可。

示例代码:

class Solution {
public:
	vector<int>rightSideView(TreeNode*root) {
		vector<int>view;
		queue<pair<TreeNode*, int>>que;
		if (root) {
			que.push(make_pair(root, 0));
		}
		while (!que.empty())
		{
			TreeNode*pNode = que.front().first;
			int depth = que.front().second;
			que.pop();
			if (view.size()==depth)//这里的if与else是将二叉树的某行的最后一个元素赋值给view
			{
				view.push_back(pNode->val);
			}
			else
			{
				view[depth] = pNode->val;//看似会产生内存泄漏，但是程序运行的逻辑会保证view的size始终大于等于depth
			}
			if (pNode->left) {
				que.push((make_pair(pNode->left, depth + 1)));
			}
			if (pNode->right) {
				que.push(make_pair(pNode->right, depth + 1));
			}
		}
		return view;
	}
};