数据结构&算法——二叉树
很多经典算法都是二叉树的变形。比如说快速排序就是个二叉树的前序遍历，归并排序就是个二叉树的后序遍历。
快速排序的逻辑是，若要对 nums[lo..hi] 进行排序，我们先找一个分界点 p，通过交换元素使得 nums[lo..p-1] 都小于等于 nums[p]，且 nums[p+1..hi] 都大于 nums[p]，然后递归地去 nums[lo..p-1] 和 nums[p+1..hi] 中寻找新的分界点，最后整个数组就被排序了。
快速排序的算法框架：
void sort(int[] nums, int lo, int hi) {
/****** 前序遍历位置 ******/
// 通过交换元素构建分界点 p
int p = partition(nums, lo, hi);
/************************/
sort(nums, lo, p - 1);
sort(nums, p + 1, hi);
}
对于归并排序，若要对 nums[lo..hi] 进行排序，我们先对 nums[lo..mid] 排序，再对 nums[mid+1..hi] 排序，最后把这两个有序的子数组合并，整个数组就排好序了。归并排序的代码框架如下：
void sort(int[] nums, int lo, int hi) {
int mid = (lo + hi) / 2;
sort(nums, lo, mid);
sort(nums, mid + 1, hi);
/****** 后序遍历位置 ******/
// 合并两个排好序的子数组
merge(nums, lo, mid, hi);
/************************/
}
二叉树问题的重点是搞清楚当前 root 节点“该做什么”以及“什么时候做”，然后根据函数定义递归调用子节点，递归调用会让孩子节点做相同的事情。
其中“该做什么”指在当前节点需要的处理行为，“什么时候做”指考虑这段代码到底应该写在前序、中序还是后序遍历的代码位置上。
翻转二叉树
// 将整棵树的节点翻转
TreeNode invertTree(TreeNode root) {
// base case
if (root == null) {
return null;
}
/**** 前序遍历位置 ****/
// root 节点需要交换它的左右子节点
TreeNode tmp = root.left;
root.left = root.right;
root.right = tmp;
// 让左右子节点继续翻转它们的子节点
invertTree(root.left);
invertTree(root.right);
return root;
}
填充二叉树节点的右侧指针
给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
struct Node { int val; Node *left; Node *right; Node *next; }填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。
class Solution {
public:
void connectHelper(Node* node1, Node* node2)
{
if(node1==nullptr)
return;
/**** 前序遍历位置 ****/
// 将传入的两个节点连接
node1->next=node2;
// 连接相同父节点的两个子节点
connectHelper(node1->left, node1->right);
connectHelper(node2->left, node2->right);
// 连接跨越父节点的两个子节点
connectHelper(node1->right,node2->left);
}
Node* connect(Node* root) {
if(root==nullptr)
return nullptr;
connectHelper(root->left, root->right);
return root;
}
};
如果我们在当前根节点只是将其左右子节点连接，可能出现的问题是，对于不是同一个父节点的两个相邻节点（跨越父节点的两个子节点）无法被连接。如果只依赖一个节点的话，肯定是没办法连接跨父节点的两个相邻节点的那么，我们的做法就是增加函数参数，一个节点做不到，我们就给他安排两个节点，「将每一层二叉树节点连接起来」可以细化成「将每两个相邻节点都连接起来」。
将二叉树展开为链表
给你二叉树的根结点 root ，请你将它展开为一个单链表：
展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null 。
展开后的单链表应该与二叉树 先序遍历 顺序相同。
class Solution {
public:
void flatten(TreeNode* root) {
if(root == nullptr)
{
return;
}
flatten(root->left); //先将左右子树都展开
flatten(root->right);
TreeNode* temp = root->right;//再将左子树放在右指针位置，左子树的最后一个节点指向右子树
root->right = root->left;
root->left = nullptr;
while(root->right!=nullptr)
{
root = root->right;
}
root->right = temp;
}
};
最大二叉树
给定一个不含重复元素的整数数组 nums 。一个以此数组直接递归构建的 最大二叉树 定义如下：
二叉树的根是数组 nums 中的最大元素。
左子树是通过数组中 最大值左边部分 递归构造出的最大二叉树。
右子树是通过数组中 最大值右边部分 递归构造出的最大二叉树。
返回有给定数组 nums 构建的 最大二叉树 。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int getMax(vector<int> nums, int low, int high)
{
if(low==high)
return low;
int maxIndex = low, maxNum = nums[low];
for(int i = low+1; i <= high; ++i)
{
if(maxNum<nums[i])
{
maxNum = nums[i];
maxIndex = i;
}
}
return maxIndex;
}
TreeNode* buildNode(vector<int> nums, int low, int high)
{
if(nums.size() == 0 || low > high)
return nullptr;
if(low==high)
{
TreeNode* node = new TreeNode(nums[low]);
return node;
}
int index = getMax(nums, low, high);
TreeNode* root = new TreeNode(nums[index]);
root->left = buildNode(nums, low, index-1);
root->right = buildNode(nums, index+1, high);
return root;
}
TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
if(nums.size()==0)
return nullptr;
TreeNode* root = buildNode(nums, 0, nums.size()-1);
return root;
}
};
对于每个根节点，只需要找到当前 nums 中的最大值和对应的索引，然后递归调用左右数组构造左右子树即可。对于这种通过索引去递归的，最好使用辅助函数显式地传入(维护)索引，更清晰不易出错。
寻找重复的子树
给定一棵二叉树，返回所有重复的子树。对于同一类的重复子树，你只需要返回其中任意一棵的根结点即可。
两棵树重复是指它们具有相同的结构以及相同的结点值。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
unordered_map<std::string, int> subTreeMap; //如果有2个以上重复的子树，结果中只能返回一次，所以使用unordered_map存储，键为序列化的子树，值 //为该子树出现的次数。
vector<TreeNode*> result;
vector<TreeNode*> findDuplicateSubtrees(TreeNode* root) {
traverse(root);
return result;
}
std::string traverse(TreeNode* root)
{
if(root == nullptr)
{
return "#";
}
std::string left = traverse(root->left);
std::string right = traverse(root->right);
string sTree = left + "," + right + "," + to_string(root->val);//序列化当前子树
if(subTreeMap.find(sTree) != subTreeMap.end()) //判断是否有重复子树
{
if(subTreeMap[sTree]==1) //若重复子树添加过，则不需要再添加
{
result.push_back(root);
subTreeMap[sTree]++;
}
}
else
{
subTreeMap.insert(make_pair(sTree, 1));
}
return sTree;
}
};
要判断以当前节点为根的子树是否有与之相同的子树，首先要清楚自己所在子树的具体内容（后序遍历求得），其次还要知道其他子树的情况（使用map存储其他子树的），当然这里需要把子树序列化来存储，常用的形式：left + “,” + right + “,” + to_string(root->val) （后序）。要注意的是如果有2个以上重复的子树，结果中只能返回一次，所以使用unordered_map存储，键为序列化的子树，值为该子树出现的次数。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
