数据结构与算法---树相关题目
递归
1.二叉搜索树与双向链表
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
TreeNode* Convert(TreeNode* pRootOfTree)
{
//空节点直接返回null
if(pRootOfTree==nullptr)
return nullptr;
//单节点直接返回此节点
if(pRootOfTree->left==nullptr && pRootOfTree->right==nullptr)
return pRootOfTree;
//递归求出左子树和右子树的排序链表结果并返回头指针
TreeNode* leftHead = Convert(pRootOfTree->left);
TreeNode* rightHead = Convert(pRootOfTree->right);
//查找到左链表的最后一个节点
TreeNode* tmp = leftHead;
while(tmp!=nullptr && tmp->right!=nullptr){
tmp = tmp->right;
}
//左链表不为空，就连接左链表和该节点
if(leftHead != nullptr){
tmp->right = pRootOfTree;
pRootOfTree->left = tmp;
}
//右链表不为空，链接
if(rightHead!=nullptr){
pRootOfTree->right = rightHead;
rightHead->left = pRootOfTree;
}
//返回头结点
return leftHead==nullptr ? pRootOfTree:leftHead;
}
2.重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
int length = vin.size();
if(length==0)
return nullptr;
struct TreeNode *head = new struct TreeNode(pre[0]);
int rootindex = 0;
vector<int> pre_left,pre_right,vin_left,vin_right;
for(int i=0;i<length;++i){
if(vin[i] == pre[0]){
rootindex = i;
break;
}
}
for(int i=0;i<rootindex;++i){
pre_left.push_back(pre[i+1]);
vin_left.push_back(vin[i]);
}
for(int i=rootindex+1;i<length;++i){
pre_right.push_back(pre[i]);
vin_right.push_back(vin[i]);
}
head->left = reConstructBinaryTree(pre_left,vin_left);
head->right = reConstructBinaryTree(pre_right,vin_right);
return head;
}
3.树的子结构
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
{
if(pRoot2==nullptr || pRoot1==nullptr) //边界条件检查
return false;
TreeNode *tmp = nullptr;
queue<TreeNode*> q;
q.push(pRoot1);
while(!q.empty()){ //树的层序遍历
tmp = q.front();
q.pop();
if(doesT1HaveT2(tmp,pRoot2)) //判断以tmp为根节点的树的子结构是否包含pRoot2
return true;
if(tmp->left)
q.push(tmp->left);
if(tmp->right)
q.push(tmp->right);
}
return false;
};
/*判断树A中以R为根节点的子树是不是和树B具有相同的结构，可以这么判断：
如果根节点R的值不等于树B根节点的值，则以R为根节点的子树和树B不具有相同结构，
如果相同，再递归判断左右节点的值是否相同；递归终止条件是到达了树A的叶节点或者
树B的叶节点 (R表示层序遍历中遍历到的当前节点） */
bool doesT1HaveT2(TreeNode* p1, TreeNode* p2){
if(p2 == nullptr) //到达数B的叶节点说明树A以R为根节点的子树包含和树B相同的结构
return true;
if(p1 == nullptr) //还没有到达树B的叶节点时已经到达树A的叶节点说明与树A此叶节点
return false; //对应的树B的节点还有左或者右节点
if(p1->val != p2->val)
return false;
return doesT1HaveT2(p1->left,p2->left) && doesT1HaveT2(p1->right,p2->right);
}
4.树的深度
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
int maxDepth(TreeNode* root) {
if(root==nullptr)
return 0;
int leftD = maxDepth(root->left);
int rightD = maxDepth(root->right);
return leftD>rightD ? leftD+1:rightD+1;
}
5.树的镜像
TreeNode* invertTree(TreeNode* root) {
if(root==nullptr)
return nullptr;
if(root->left==nullptr && root->right==nullptr)
return root;
TreeNode *left = invertTree(root->left);
TreeNode *right = invertTree(root->right);
root->left = right;
root->right = left;
return root;
}
6.合并两棵二叉树
给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。
你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。
TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
if(t1==nullptr && t2==nullptr)
return nullptr;
if(t1==nullptr)
return t2;
if(t2==nullptr)
return t1;
TreeNode *root = new TreeNode(t1->val+t2->val);
root->left = mergeTrees(t1->left,t2->left);
root->right = mergeTrees(t1->right,t2->right);
return root;
}
7.1路径总和
给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。
bool hasPathSum(TreeNode* root, int sum) {
if(root==nullptr)
return false;
if((root->left == nullptr) && (root->right == nullptr)){
if(sum == root->val)
return true;
}
return hasPathSum(root->left, sum-root->val) || hasPathSum(root->right, sum-root->val);
}
此题还有一个变形，打印出等于某个值的路径，见下题
7.2 路径总和
给定一个二叉树，它的每个结点都存放着一个整数值。
找出路径和等于给定数值的路径总数。
路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。
二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。
int pathSum(TreeNode* root, int sum) {
if(root==nullptr)
return 0;
int ret = pathSumRoot(root,sum) + pathSum(root->left,sum) + pathSum(root->right,sum);
return ret;
}
int pathSumRoot(TreeNode *root,int sum){
if(root==nullptr)
return 0;
int ret = 0;
if(root->val==sum) ret++;
ret += pathSumRoot(root->left,sum-root->val) + pathSumRoot(root->right,sum-root->val);
return ret;
}
8.树的镜像
给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
但是 [1,2,2,null,3,null,3] 则不是镜像对称的:
bool isSymmetric(TreeNode* root) {
if(root==nullptr) return true;
return isSymmetric(root->left,root->right);
}
bool isSymmetric(TreeNode *left,TreeNode *right){
if(left==nullptr && right==nullptr) return true;
if(left==nullptr || right==nullptr) return false;
if(left->val != right->val) return false;
return isSymmetric(left->left,right->right) && isSymmetric(left->right,right->left);
}
9.二叉树的最小深度
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
https://leetcode.com/problems/minimum-depth-of-binary-tree/
int minDepth(TreeNode* root) {
if(root==nullptr) return 0;
int left = minDepth(root->left);
int right = minDepth(root->right);
if(left==0 || right==0) return left+right+1;
return min(left,right) + 1;
}
10.左叶子之和
计算给定二叉树的所有左叶子之和。
https://leetcode.com/problems/sum-of-left-leaves/description/
int sumOfLeftLeaves(TreeNode* root) {
if(root==nullptr) return 0;
if(isLeaf(root->left)) return root->left->val + sumOfLeftLeaves(root->right);
return sumOfLeftLeaves(root->left) + sumOfLeftLeaves(root->right);
}
bool isLeaf(TreeNode *root){
if(root==nullptr) return false;
return root->left==nullptr && root->right==nullptr;
}
层序遍历
使用 BFS 进行层次遍历。只需记下每层的节点数目，用一个队列即可完成每层输出。
11.一棵树每层节点的平均数
Given a non-empty binary tree, return the average value of the nodes on each level in the form of an array.
https://leetcode.com/problems/average-of-levels-in-binary-tree/
vector<double> averageOfLevels(TreeNode* root) {
if(root==nullptr) return vector<double>(0);
queue<TreeNode*> q;
vector<double> v;
q.push(root);
int currentNum = 1;
int nextNum = 0;
double avg = 0.0;
while(!q.empty()){
nextNum = 0;
avg = 0;
int i = currentNum;
while(i){
TreeNode *tmp = q.front();
q.pop();
avg += tmp->val;
if(tmp->left!=nullptr){
q.push(tmp->left);
nextNum++;
}
if(tmp->right!=nullptr){
q.push(tmp->right);
nextNum++;
}
--i;
}
avg /= currentNum;
v.push_back(avg);
currentNum = nextNum;
}
return v;
}
12.得到左下角的节点
Given a non-empty binary tree, return the average value of the nodes on each level in the form of an array.
https://leetcode.com/problems/average-of-levels-in-binary-tree/
int findBottomLeftValue(TreeNode* root) {
queue<TreeNode*> q;
q.push(root);
while(!q.empty()){
int num = q.size();
int i = num;
TreeNode *leftNode = nullptr;
while(i){
TreeNode *tmp = q.front();
q.pop();
if(i==num)
leftNode = tmp;
if(tmp->left!=nullptr) q.push(tmp->left);
if(tmp->right!=nullptr) q.push(tmp->right);
--i;
}
if(q.empty())
return leftNode->val;
}
return -1;
}
上面两个题都是同样的思路，用队列存储每层的节点，然后根据每层的节点数输出。
BST
13.修剪BST
Given a binary search tree and the lowest and highest boundaries as L and R, trim the tree so that all its elements lies in [L, R] (R >= L). You might need to change the root of the tree, so the result should return the new root of the trimmed binary search tree.
https://leetcode.com/problems/trim-a-binary-search-tree/
TreeNode* trimBST(TreeNode* root, int L, int R) {
if(root==nullptr) return nullptr;
if(root->val > R) return trimBST(root->left,L,R);
if(root->val < L) return trimBST(root->right,L,R);
root->left = trimBST(root->left,L,R);
root->right = trimBST(root->right,L,R);
return root;
}
14.BST最小第k个值
https://leetcode.com/problems/kth-smallest-element-in-a-bst/
class Solution {
public:
int kthSmallest(TreeNode* root, int k) {
preOrder(root,k);
return result;
}
void preOrder(TreeNode* root,int k){
if(root){
preOrder(root->left,k);
time++;
if(time==k){
result = root->val;
}
preOrder(root->right,k);
}
}
private:
int time=0; //类内初始化值
int result;
};
15.BST把二叉查找树每个节点的值都加上比它大的节点的值
Given a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original BST is changed to the original key plus sum of all keys greater than the original key in BST.
https://leetcode.com/problems/convert-bst-to-greater-tree/
class Solution {
public:
TreeNode* convertBST(TreeNode* root) {
inOrder(root);
return root;
}
void inOrder(TreeNode* root){
if(root){
inOrder(root->right);
root->val += sum;
sum = root->val;
inOrder(root->left);
}
}
private:
int sum=0;
};
16.二叉查找树的最近公共祖先
https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
if(root->val > p->val && root->val > q->val){
return lowestCommonAncestor(root->left,p,q);
}
if(root->val < p->val && root->val < q->val){
return lowestCommonAncestor(root->right,p,q);
}
return root;
}
17.二叉树最近公共祖先（middle）
https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/
18.从有序数组中构造二叉查找树
https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/
TreeNode* sortedArrayToBST(vector<int>& nums) {
int size = nums.size();
if(size==0)
return nullptr;
int middle = (size-1)/2;
int middleVal = nums[middle];
TreeNode* node = new TreeNode(middleVal);
vector<int> leftnums(nums.begin(),nums.begin()+middle);
vector<int> rightnums(nums.begin()+middle+1,nums.end());
TreeNode* left = sortedArrayToBST(leftnums);
TreeNode* right = sortedArrayToBST(rightnums);
node->left = left;
node->right = right;
return node;
}
19.根据有序链表构造平衡的二叉查找树
https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/description/
20.在二叉查找树中寻找两个节点，使它们的和为一个给定值
https://leetcode.com/problems/two-sum-iv-input-is-a-bst/
将遍历过的值放入一个set中，然后查找target-当前节点值 是否在set中
class Solution {
public:
bool findTarget(TreeNode* root, int k) {
traversal(root,k);
return ret;
}
void traversal(TreeNode* root,int k){
if(root){
traversal(root->left,k);
if(s.find(k-root->val) != s.end()){
ret = true;
return;
}
s.insert(root->val);
traversal(root->right,k);
}
}
private:
unordered_set<int> s;
bool ret=false;
};
非递归
21.非递归前序遍历二叉树
vector<int> preorderTraversal(TreeNode* root) {
vector<int> v;
stack<TreeNode*> s;
s.push(root);
while(!s.empty()){
TreeNode* tmp = s.top();
s.pop();
if(tmp==nullptr) continue;
v.push_back(tmp->val);
s.push(tmp->right); //先右后左保证出栈顺序
s.push(tmp->left);
}
return v;
}
22.非递归后续遍历
前序遍历是root->left->right，压栈顺序是root->right->left，后序遍历是left->right->root，如果压栈顺序是root->left->right，则输出顺序是root->right->left，这个顺序刚好和后序遍历相反，最后在翻转即可。
23.非递归中序遍历
vector<int> inorderTraversal(TreeNode* root) {
vector<int> v;
if(root==nullptr) return v;
stack<TreeNode*> s;
//s.push(root);
TreeNode* cur = root;
while(cur!=nullptr || !s.empty()){
while(cur!=nullptr){
s.push(cur);
cur = cur->left;
}
TreeNode* tmp = s.top();
s.pop();
v.push_back(tmp->val);
cur = tmp->right;
}
return v;
}
查找根节点的最左子树，沿途一直将节点压栈，直到找到最左子树，然后弹栈，访问弹出节点的值，再对该节点的右节点执行前面的过程，直到栈为空。