Leetcode学习之二叉树与图（1）

开宗明义：本系列基于小象学院林沐老师课程《面试算法 LeetCode 刷题班》，刷题小白，旨在理解和交流，重在记录，望各位大牛指点！

---

Leetcode学习之二叉树与图（1）

---

---

1、二叉树

树是 $n（n>=0）$个节点的有限集，且这些节点满足如下关系：

1. 有且只有一个节点没有父节点，这个节点被称为根；
2. 除根外，其余每个节点都有且仅有一个父节点；
3. 树中的每一个节点都构成一个以它为根的树；

二叉树满足树的条件下，也还满足：每个节点最多两个孩子（子树），这两个子树有左右之分，次序不可预测。

二叉树的构造：
测试代码：

#include <stdio.h>
#include <iostream>

struct TreeNode {//二叉树的数据结构
	int val;    //数据域
	TreeNode *left; //left,right左右子树指针
	TreeNode *right;
	TreeNode(int x) :val(x), left(NULL), right(NULL) {}
};

void preorder_print(TreeNode *node, int layer) {  //正在遍历的节点，当前节点的层数
	if (!node) {//递归结束条件
		return;
	}

	for (int i = 0; i < layer; i++) {//操作
		printf("----");//根据层数，打印相应数量的'-'
	}
	printf("[%d]\n", node->val);
	preorder_print(node->left, layer + 1);//遍历左子树，层数+1
	preorder_print(node->right, layer + 1);//遍历右子树，层数+1
}

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;
	preorder_print(&a, 0);
	system("pause");
	return 0;
}

效果图：

---

2、二叉树的深度遍历

分析：

关于前序后续中序：

A：根节点；B：左节点；C：右节点；
前序遍历：ABC（根节点->左节点->右节点）；
中序遍历：BAC（左节点->根节点->右节点）；
后序遍历：BCA（左节点->右节点->根节点）；

测试代码：

#include <stdio.h>

struct TreeNode //二叉树数据结构
{
	int val;//数据域val
	TreeNode *left;//left，right左右子树指针
	TreeNode *right;
	TreeNode(int x) :val(x), left(NULL), right(NULL) {}
};

void traversal_print1(TreeNode *node, int layer) {
	if (!node) {
		return;
	}
	traversal_print1(node->left, layer + 1);//中序遍历
	for (int i = 0; i < layer; i++) {
		printf("-----");
	}
	printf("[%d]\n", node->val);
	traversal_print1(node->right, layer + 1);
}

void traversal_print2(TreeNode *node, int layer) {//后序遍历
	if (!node) {
		return;
	}
	traversal_print2(node->left, layer + 1);
	traversal_print2(node->right, layer + 1);
	for (int i = 0; i < layer; i++) {
		printf("-----");
	}
	printf("[%d]\n", node->val);
}

void traversal_print3(TreeNode *node, int layer) {//前序遍历
	if (!node) {
		return;
	}
	for (int i = 0; i < layer; i++) {
		printf("-----");
	}
	printf("[%d]\n",node->val);
	traversal_print3(node->left, layer + 1);
	traversal_print3(node->right, layer + 1);
}

---

3、路径之和 Leetcode 113.

题目来源：$Leetcode113.PathSum$
题目描述：给定一个二叉树与整数sum，找出所有从根节点到叶节点的路径，这些路径上的节点值累加和为sum。
要求描述：

分析：

测试代码：

#include <stdio.h>
#include <vector>
using namespace std;

struct TreeNode //二叉树数据结构
{
	int val;//数据域val
	TreeNode *left;//left，right左右子树指针
	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;
	}
private:
	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 (!node->left && !node->right&&path_value == sum) {//从根节点到叶节点，停止条件，才将path加入到结果数组
			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();//遍历完成后，将该节点从路径栈中弹出
	}
};

int main() {
	TreeNode a(5), b(4), c(8), d(11), e(13), f(4), g(7), h(2), x(5), y(1);
	a.left = &b;
	a.right = &c;
	b.left = &d;
	c.left = &e;
	c.right = &f;
	d.left = &g;
	d.right = &h;
	f.left = &x;
	f.right = &y;
	Solution solve;
	vector<vector<int>> result = solve.pathSum(&a, 22);
	for (int i = 0; i < result.size(); i++) {
		for (int j = 0; j < result[i].size(); j++) {
			printf("[%d]", result[i][j]);
		}
		printf("\n");
	}
	system("pause");
	return 0;
}

效果图：

3、最近的公共祖先 Leetcode 236.

题目来源：$Leetcode236.LowestCommonAncestorofaBinaryTree$
题目描述：已知二叉树，求二叉树中给定的两个节点的最近公共祖先。最近的公共祖先指：两节点v与w的最近公共祖先u，满足在树上最低(离根最远)，且v,w两个节点都是u的子孙。
要求描述：

分析：
第一步：

第二步：

测试代码：

#include <stdio.h>
#include <vector>
using namespace std;

struct TreeNode //二叉树数据结构
{
	int val;//数据域val
	TreeNode *left;//left，right左右子树指针
	TreeNode *right;//
	TreeNode(int x) :val(x), left(NULL), right(NULL) {}
};

//前序遍历(深度优先遍历)  正在遍历的节点
void preorder(TreeNode *node, //正在遍历的节点
	TreeNode *search,//待搜索的节点
	vector<TreeNode*> &path,//遍历时的节点路径栈
	vector<TreeNode*> &result,//最终搜索到节点search的路径的结果
	int &finish) {//记录是否找到节点search的变量，未找到时是0，找到为1
	if (!node || finish) {//当node为空或已经找到search节点直接返回，结束搜索
		return;
	}
	path.push_back(node);//送进去
	if (node == search) {
		finish = 1;
		result = path;
	}
	preorder(node->left, search, path, result, finish);//深度遍历node左孩子
	preorder(node->right, search, path, result, finish);//深度遍历node右孩子
	path.pop_back();//结束遍历时，将node弹出去
}

class Solution {
public:
	TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
		vector<TreeNode*> path;//声明遍历用的临时栈
		vector<TreeNode*> node_p_path;//存储p节点路径
		vector<TreeNode*> node_q_path;//存储q节点路径
		int finish = 0;//记录是否完成搜索的变量finish
		preorder(root, p, path, node_p_path, finish);
		path.clear();
		finish = 0;//清空path，finish，计算q节点路径
		preorder(root, q, path, node_q_path, finish);
		int path_len = 0;//较短路径的长度

		if (node_p_path.size() < node_q_path.size()) {
			path_len = node_p_path.size();
		}
		else
		{
			path_len = node_q_path.size();
		}
		TreeNode *result = 0;//同时遍历根到p,q两个节点的路径上面的节点
		for (int i = 0; i < path_len; i++) {
			if (node_p_path[i] == node_q_path[i]) {
				result = node_p_path[i];//找到最近的公共祖先
			}
		}
		return result;
	}
};

int main() {
	TreeNode a(3), b(5), c(1), d(6), e(2), f(0), x(8), y(7), z(4);
	a.left = &b;
	a.right = &c;
	b.left = &d;
	b.right = &e;
	c.left = &f;
	c.right = &x;
	e.left = &y;
	e.right = &z;
	Solution solve;
	TreeNode *result = solve.lowestCommonAncestor(&a, &b, &f);
	printf("lowestCommonAncestor = %d\n", result->val);

	result = solve.lowestCommonAncestor(&a, &d, &z);
	printf("lowestCommonAncestor = %d\n", result->val);

	result = solve.lowestCommonAncestor(&a, &b, &y);
	printf("lowestCommonAncestor = %d\n", result->val);

	system("pause");
	return 0;
}

效果图：