# 1 Same Tree

https://leetcode.com/problems/same-tree/

Given two binary trees, write a function to check if they are equal or not.

Two binary trees are considered equal if they are structurally identical and the nodes have the same 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:
bool isSameTree(TreeNode* p, TreeNode* q) {
if (p == NULL && q == NULL) {
return true;
}

if (p == NULL || q == NULL) {
return false;
}

if (p->val != q->val) {
return false;
}

return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
};

# 2 SubTree

http://www.lintcode.com/en/problem/subtree/

You have two every large binary trees: T1, with millions of nodes, and T2, with hundreds of nodes. Create an algorithm to decide if T2 is a subtree of T1.

Example

T2 is a subtree of T1 in the following case:

       1                3
/ \              /
T1 = 2   3      T2 =  4
/
4


T2 isn't a subtree of T1 in the following case:

       1               3
/ \               \
T1 = 2   3       T2 =    4
/
4
仍然是分治的思想。如果T1当前root节点与T2的root节点相同，我们才有兴趣判断T2是否是T1的子树。如果不同，判断T2是否是T1的左子树的子树或者是T1的右子树的子树。
/**
* Definition of TreeNode:
* class TreeNode {
* public:
*     int val;
*     TreeNode *left, *right;
*     TreeNode(int val) {
*         this->val = val;
*         this->left = this->right = NULL;
*     }
* }
*/
class Solution {
public:
/**
* @param T1, T2: The roots of binary tree.
* @return: True if T2 is a subtree of T1, or false.
*/
bool isSubtree(TreeNode *T1, TreeNode *T2) {
if (T2 == NULL) {
return true;
}

// //we have exhauste the root1 already
if (T1 == NULL) {
return false;
}

if (T1->val == T2->val) {
if (isSameTree(T1, T2)) {
return true;
}
}

return isSubtree(T1->left, T2) || isSubtree(T1->right, T2);
}

private:
bool isSameTree(TreeNode *T1, TreeNode *T2) {
if (T1 == NULL && T2 == NULL) {
return true;
}

if (T1 == NULL || T2 == NULL) {
return false;
}

if (T1->val != T2->val) {
return false;
}

return isSameTree(T1->left, T2->left) && isSameTree(T1->right, T2->right);
}
};

# 3 计算树的深度

int treeDepth(TreeNode *root) {
// base case
if (root == NULL) {
return 0;
}

return max(treeDepth(root->left), treeDepth(root->right)) + 1;
}

# 4 Path Sum

https://leetcode.com/problems/path-sum/

Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.

For example:
Given the below binary tree and sum = 22,

              5
/ \
4   8
/   / \
11  13  4
/  \      \
7    2      1

return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.

/**
* 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:
bool hasPathSum(TreeNode* root, int sum) {
// base case
if (root == NULL) {
return false;
}

// 当前递归层是否满足条件？
if (root->val == sum && root->left == NULL && root->right == NULL) {
return true;
}

return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
}
};

# 5 Path Sum II

https://leetcode.com/problems/path-sum-ii/

Given a binary tree and a sum, find all root-to-leaf paths where each path's sum equals the given sum.

For example:
Given the below binary tree and sum = 22,

              5
/ \
4   8
/   / \
11  13  4
/  \    / \
7    2  5   1

return

[
[5,4,11,2],
[5,8,4,5]
]
解法1：
dfs中的sum参数记录了当前递归层需要满足的条件
/**
* 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;
dfs(root, result, path, sum);
return result;
}

private:
void dfs(TreeNode *root, vector<vector<int>> &result, vector<int> &path, int sum) {
if (root == NULL) {
return;
}

path.push_back(root->val);

if (root->val == sum && root->left == NULL && root->right == NULL) {
result.push_back(path);
}

dfs(root->left, result, path, sum - root->val);
dfs(root->right, result, path, sum - root->val);

path.pop_back();
}
};

/**
* 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;
dfs(root, result, path, sum);
return result;
}

private:
void dfs(TreeNode *root, vector<vector<int>> &result, vector<int> &path, const int &sum) {

if (root == NULL) {
return;
}

path.push_back(root->val);

if (root->left == NULL && root->right == NULL) {

int tmp = 0;

for (vector<int>::const_iterator itr = path.cbegin(); itr != path.cend(); itr++) {
tmp += *itr;
}

if (tmp == sum) {
result.push_back(path);
}
}

dfs(root->left, result, path, sum);
dfs(root->right, result, path, sum);
path.pop_back();
}
};

# 6 Binary Tree Maximum Path Sum

https://leetcode.com/problems/binary-tree-maximum-path-sum/

Given a binary tree, find the maximum path sum.

The path may start and end at any node in the tree.

For example:
Given the below binary tree,

       1
/ \
2   3

Return 6.

/**
* Definition for a binary tree node.
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
struct returnType {
returnType(int singlePath, int doublePath)
:singlePath_(singlePath), doublePath_(doublePath)
{ }

int singlePath_;
int doublePath_;
};

class Solution {
public:
int maxPathSum(TreeNode* root) {
return maxPathSumHelper(root).doublePath_;
}

private:
returnType maxPathSumHelper(TreeNode *root) {
if (root == NULL) {
return returnType(0, numeric_limits<int>::min());
}

// devide
returnType left = maxPathSumHelper(root->left);
returnType right = maxPathSumHelper(root->right);

// conquer
int singlePath = getMax(left.singlePath_ + root->val, right.singlePath_ + root->val, root->val);
int doublePath = getMax(left.doublePath_, right.doublePath_, max(left.singlePath_ + right.singlePath_ + root->val, singlePath));

return returnType(singlePath, doublePath);
}

int getMax(int x, int y, int z) {
return (x = x > y ? x : y ) > z ? x : z;
}

};

# 7 最近公共祖先

###### 最近公共祖先

  4
/ \
3   7
/ \
5   6


LCA(3, 5) = 4

LCA(5, 6) = 7

LCA(6, 7) = 7

如果两个节点都在同一棵子树中，则继续往该子树中查找。如果两个节点在不同的子树中，那么root即为最近公共祖先。

/**
* 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:
TreeNode *lowestCommonAncestor(TreeNode *root, TreeNode *p, TreeNode *q) {
// p,q均在左子树中
if (covers(root->left, p) && covers(root->left, q)) {
return lowestCommonAncestor(root->left, q, p);
}
// p,q均在右子树中
if (covers(root->right, p) && covers(root->right, q)) {
return lowestCommonAncestor(root->right, q, p);
}

// base case：p,q在不同的子树中，或者root即为p,q中的某一个节点
return root;
}

// 辅助函数，判断节点p是否在子树中。
bool covers(TreeNode *root, TreeNode *p) {
if (root == NULL) {
return false;
}

if (root == p) {
return true;
}

return covers(root->left, p) || covers(root->right, p);
}
};

# 8 Convert Sorted Array to Binary Search Tree

Tree与其他数据结构转换这类题⽬目要求将树的结构转化成其他数据结构，例如linked list, array等，或者反之，从array等结构构成⼀棵树。

https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/

Given an array where elements are sorted in ascending order, convert it to a height balanced BST.

/**
* 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:
TreeNode* sortedArrayToBST(vector<int>& nums) {
return sortedArrayToBstHelper(nums, 0, nums.size() - 1);
}

private:
TreeNode* sortedArrayToBstHelper(const vector<int> &nums, int start, int end) {

if (start > end) {
return NULL;
}

if (start == end) {
return new TreeNode(nums[start]);
}

int mid = start + ((end - start) >> 1);
TreeNode *l  = sortedArrayToBstHelper(nums, start, mid - 1);
TreeNode *r = sortedArrayToBstHelper(nums, mid + 1, end);

TreeNode *root = new TreeNode(nums[mid]);
root->left = l;
root->right = r;
return root;
}
};

9

posted @ 2015-08-30 19:06  Acjx  阅读(634)  评论(0编辑  收藏  举报