二叉樹考點主要有:

1.三種遍歷方式,以及構造二叉樹等；

2.求深度,最長直徑，最長路徑,公共祖先等等;

3.合并二叉樹，翻轉二叉樹，判斷平衡性,對稱性等;

4.從前序與中序構造二叉樹，中序與后序構造二叉樹，二叉樹序列化等;

5.二叉搜索樹

1-1.前序遍歷

思路１：遞歸法?

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def helper(self, node):if node is not None:self.res.append(node.val)self.helper(node.left)self.helper(node.right)def preorderTraversal(self, root: TreeNode) -> List[int]:self.res = []self.helper(root)return self.res

c++實現:

/*** 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:vector<int> res;void help(TreeNode* node){if(node !=nullptr){res.push_back(node->val);help(node->left);help(node->right);}}vector<int> preorderTraversal(TreeNode* root) {help(root);return res;} };

思路２棧（迭代法）：

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def preorderTraversal(self, root: TreeNode) -> List[int]: res = []if root is None:return resstack = [root]while stack:node = stack.pop()if node:res.append(node.val)stack.append(node.right)stack.append(node.left)return res

c++實現:

/*** 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:vector<int> preorderTraversal(TreeNode* root) {vector<int>res;stack<TreeNode*> stack_A;stack_A.push(root);while(stack_A.size()>0){TreeNode* node = stack_A.top();stack_A.pop();if(node){res.push_back(node->val);stack_A.push(node->right);stack_A.push(node->left);}}return res;} };

1-2.N叉樹的前序遍歷

1.遞歸法?

""" # Definition for a Node. class Node:def __init__(self, val=None, children=None):self.val = valself.children = children """class Solution:def preorder(self, root: 'Node') -> List[int]:res = []def helper(node):if node:res.append(node.val)for child in node.children:helper(child)helper(root)# print('res:', res)return res

c++實現:

/* // Definition for a Node. class Node { public:int val;vector<Node*> children;Node() {}Node(int _val) {val = _val;}Node(int _val, vector<Node*> _children) {val = _val;children = _children;} }; */class Solution { public:vector<int> res;void help(Node* node){if(node!=NULL){res.push_back(node->val);vector<Node* > new_nodes = node->children;for(int i=0;i<new_nodes.size();i++){help(new_nodes[i]);}}}vector<int> preorder(Node* root) {help(root);return res;} };

2.迭代法 利用棧

""" # Definition for a Node. class Node:def __init__(self, val=None, children=None):self.val = valself.children = children """class Solution:def preorder(self, root: 'Node') -> List[int]: res= []if root is None:return resstack = [root]while stack:node = stack.pop()if node:res.append(node.val)stack.extend(node.children[::-1])# print('==res:', res)return res

c++實現:

/* // Definition for a Node. class Node { public:int val;vector<Node*> children;Node() {}Node(int _val) {val = _val;}Node(int _val, vector<Node*> _children) {val = _val;children = _children;} }; */ //后進左子樹先出左子樹 class Solution { public:vector<int> preorder(Node* root) {if(root==NULL){return {};}vector<int> res;stack<Node*> stack_A;stack_A.push(root);while (stack_A.size()>0){Node* node = stack_A.top();stack_A.pop();if(node){res.push_back(node->val);vector<Node*> temp_node_list = node->children;for (int i=temp_node_list.size()-1;i>=0;i--){stack_A.push(temp_node_list[i]);}}}return res;} };

1-3.中序遍歷

思路１：遞歸法?

# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution:def helper(self, node):if node is not None:self.helper(node.left)self.res.append(node.val)self.helper(node.right)def inorderTraversal(self, root: TreeNode) -> List[int]:self.res = []self.helper(root)return self.res

c++實現:

/*** 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:vector<int>res;void help(TreeNode* node){if(node){help(node->left);res.push_back(node->val);help(node->right);}}vector<int> inorderTraversal(TreeNode* root) {help(root);return res;} };

思路2.棧（迭代法）

# Definition for a binary tree node. # class TreeNode(object): # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution(object):def inorderTraversal(self, root):""":type root: TreeNode:rtype: List[int]"""stack = []node = rootoutput = []if root == None: return outputwhile node or stack: # 如果node和aStack都是空的，說明全查完了。while node: # 如果node是空的，說明左邊沒子節點了。stack.append(node)node = node.leftnode = stack.pop() # 左邊沒子節點了就輸出棧頂的節點值，然后從它右邊的子節點繼續。output.append(node.val)node = node.rightreturn output

1-4.后序遍歷

思路１：遞歸?

# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution:def helper(self, node):if node:self.helper(node.left)self.helper(node.right)self.res.append(node.val)def postorderTraversal(self, root: TreeNode) -> List[int]:self.res = []self.helper(root)return self.res

c++實現:

/*** 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:vector<int> res;void help(TreeNode* node){if(node!=nullptr){help(node->left);help(node->right);res.push_back(node->val);}}vector<int> postorderTraversal(TreeNode* root) {help(root);return res;} };

?思路２：棧（迭代法）

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def postorderTraversal(self, root: TreeNode) -> List[int]:stack = []res = []prev = Nonewhile root or stack:while root:stack.append(root)root = root.leftroot = stack.pop()if not root.right or root.right == prev:#右子樹為空或者為根節點值已經遍歷過　prev已經記錄右節點的值res.append(root.val)prev = rootroot = Noneelse:stack.append(root)root = root.rightreturn res

1-5.N叉樹的后序遍歷

1. 解法1 遞歸法

#遞歸法 """ # Definition for a Node. class Node:def __init__(self, val=None, children=None):self.val = valself.children = children """class Solution:def postorder(self, root: 'Node') -> List[int]:if root is None:return Noneres = []def helper(t):if t is None:returnfor child in t.children:helper(child)res.append(t.val)helper(root)return res

c++實現:

/* // Definition for a Node. class Node { public:int val;vector<Node*> children;Node() {}Node(int _val) {val = _val;}Node(int _val, vector<Node*> _children) {val = _val;children = _children;} }; */class Solution { public:vector<int> res;void help(Node* node){if(node == NULL){return ;}for(int i=0; i < node->children.size(); i++){help(node->children[i]);} res.push_back(node->val); }vector<int> postorder(Node* root) {if (root==NULL){return {};}help(root);return res;} };

2. 解法2 迭代法

#迭代法 """ # Definition for a Node. class Node:def __init__(self, val=None, children=None):self.val = valself.children = children """class Solution:def postorder(self, root: 'Node') -> List[int]:if root is None:return Nonestack= [root]res = []while stack:node = stack.pop()res.append(node.val)for child in node.children:stack.append(child)return res[::-1]

1-6.從上到下打印二叉樹

1.BFS:思路利用bfs將每一層節點進行存儲?

# Definition for a binary tree node. # class TreeNode(object): # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution(object):def levelOrder(self, root):""":type root: TreeNode:rtype: List[int]"""if root is None:return []quene = [root]res = []while quene:node = quene.pop(0)res.append(node.val)if node.left is not None:quene.append(node.left)if node.right is not None:quene.append(node.right)return res

c++實現:

/*** 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<int> levelOrder(TreeNode* root) {vector<int>res;if(!root){return {};}queue<TreeNode*> queue_A;queue_A.push(root);while(!queue_A.empty()){TreeNode* node = queue_A.front();res.push_back(node->val);queue_A.pop();if(node->left){queue_A.push(node->left);}if(node->right){queue_A.push(node->right);}}return res;} };

1-7.從上到下打印二叉樹 II

思路：從跟節點開始一層一層遍歷

1.遞歸法：要注意的是判斷節點是同一層，此時可以傳入一個level參數用于控制層數

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def levelOrder(self, root: TreeNode) -> List[List[int]]:res = []def backtrace(t, level):if t:if len(res)==level:res.append([])res[level].append(t.val)backtrace(t.left,level+1)backtrace(t.right,level+1)backtrace(root,0)return res

2.迭代法 BFS

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def levelOrder(self, root: TreeNode) -> List[List[int]]:res = []if not root:return resquene= [root]while quene: temp = []# print('==len(quene):', len(quene))for i in range(len(quene)):node = quene.pop(0)temp.append(node.val) # print('==temp:', temp) if node.left:quene.append(node.left)if node.right: quene.append(node.right)res.append(temp)return res

c++實現:

/*** 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>> levelOrder(TreeNode* root) {vector<vector<int>> res; if(!root){return {};}queue<TreeNode* > queue_A;queue_A.push(root);while(!queue_A.empty()){ vector<int> temp_res;int count = queue_A.size();for (int i=0;i<count;i++){ TreeNode* node = queue_A.front();temp_res.push_back(node->val);queue_A.pop();if(node->left){queue_A.push(node->left);}if(node->right){queue_A.push(node->right);}}res.push_back(temp_res); }return res;}};

1-8.從上到下打印二叉樹 III

1.思路BFS :將每一層節點存入隊列進行遍歷,對奇數層進行逆序加入即可

# Definition for a binary tree node. # class TreeNode(object): # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution(object):def levelOrder(self, root):""":type root: TreeNode:rtype: List[List[int]]"""if root is None:return []quene = [root]res =[]while quene:temp = []for i in range(len(quene)):node = quene.pop(0)temp.append(node.val)if node.left is not None:quene.append(node.left) if node.right is not None:quene.append(node.right)if len(res)%2==1:res.append(temp[::-1])else:res.append(temp)# print('==res:', res)return res

c++實現:

/*** 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>> levelOrder(TreeNode* root) {vector<vector <int>> res;if (root==NULL){return {};}queue<TreeNode* > queue_A;queue_A.push(root);while(!queue_A.empty()){vector <int> temp_res;int count = queue_A.size();for (int i=0;i<count;i++){TreeNode* node = queue_A.front(); temp_res.push_back(node->val);queue_A.pop();if(node->left){queue_A.push(node->left);}if(node->right){queue_A.push(node->right);}}if(res.size()%2==0){res.push_back(temp_res);}else{reverse(temp_res.begin(),temp_res.end());res.push_back(temp_res);} }return res;} };

?1-9.二叉樹的鋸齒形層次遍歷

思路:將每一層的結果進行保存,最后在奇數層反轉即可

1.遞歸解法?

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def help(self,node,level):if node:if len(self.res) == level:self.res.append([])self.res[level].append(node.val)self.help(node.left,level+1)self.help(node.right,level+1)def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:self.res = []if root is None:return self.resself.help(root, 0)for i in range(len(self.res)):if i%2==1:self.res[i] = self.res[i][::-1]return self.res

2.迭代解法

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:res = []if root is None:return resquene = [root]while quene:temp = []for i in range(len(quene)):node = quene.pop(0)temp.append(node.val)if node.left is not None:quene.append(node.left)if node.right is not None:quene.append(node.right)res.append(temp)for i in range(len(res)):if i%2==1:res[i] = res[i][::-1] return res

1-10.遞增順序查找樹

思路:中序遍歷獲取每個節點的值,在利用值構建樹?

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def increasingBST(self, root: TreeNode) -> TreeNode:res= []if root is None:return resdef helper(node):if node:helper(node.left)res.append(node.val)helper(node.right)helper(root)print('res:', res)#構建樹new_node = TreeNode(res[0])current_node=new_nodefor i in range(len(res)-1):current_node.left = Nonecurrent_node.right = TreeNode(res[i+1])current_node = current_node.rightreturn new_node

c++實現:

/*** 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:vector <int> res;void help(TreeNode* node){if(node == nullptr){return ;}help(node->left);res.push_back(node->val);help(node->right);}TreeNode* increasingBST(TreeNode* root) {if(root == nullptr){return nullptr;}help(root);TreeNode* new_root = new TreeNode(res[0]);TreeNode* temp_node = new_root;for(int i=1;i<res.size();i++){temp_node->left = nullptr;temp_node->right = new TreeNode(res[i]);temp_node = temp_node->right;}return new_root;} };

?1-11.?二叉樹的右視圖

思路：每一層進行遍歷存儲結果,將每一層的右側結果進行輸出即可。

1.迭代法

# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution:def rightSideView(self, root: TreeNode) -> List[int]:res = []if root is None:return resqueue = [root]while queue:size = len(queue)for i in range(len(queue)):node = queue.pop(0)if i == size - 1 :res.append(node.val)if node.left is not None:queue.append(node.left)if node.right is not None:queue.append(node.right)return res

c++實現:

/*** 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:vector<int> res;vector<int> rightSideView(TreeNode* root) {if(root == nullptr) {return {};}queue<TreeNode*> queue_A(r);queue_A.push(root);while(!queue_A.empty()){int count = queue_A.size();for (int i = 0; i < count; i++){TreeNode* temp_node = queue_A.front();if(i == count - 1){res.push_back(temp_node->val);}queue_A.pop();if(temp_node->left!=nullptr){queue_A.push(temp_node->left);}if(temp_node->right!=nullptr){queue_A.push(temp_node->right);} }}return res;} };

2.遞歸法

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def rightSideView(self, root: TreeNode) -> List[int]:res =[]if root is None:return resdef helper(node, level):if node is not None:if len(res) == level:res.append([])res[level].append(node.val)helper(node.left,level+1)helper(node.right,level+1)helper(root, 0)# print('====res:', res)fin_res =[]for i in range(len(res)):fin_res.append(res[i][-1])return fin_res

1-12. 找樹左下角的值

思路:bfs

python:

# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution:def findBottomLeftValue(self, root: TreeNode) -> int:nodes = [root]res = []while nodes:temp = nodes[0]for i in range(len(nodes)):node = nodes.pop(0)if node.left:nodes.append(node.left)if node.right:nodes.append(node.right) if len(nodes) == 0:return temp.val

c++:

/*** 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 findBottomLeftValue(TreeNode* root) {queue<TreeNode* > nodes;nodes.push(root);while(!nodes.empty()){TreeNode* temp = nodes.front();int count = nodes.size();for(int i = 0; i < count; i++){TreeNode* node = nodes.front();nodes.pop();if(node->left){nodes.push(node->left);}if(node->right){nodes.push(node->right);}}if(nodes.size() == 0){return temp->val;}}return -1;} };

2-1.二叉樹的深度

遞歸:python代碼

# Definition for a binary tree node. # class TreeNode(object): # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution(object):def maxDepth(self, root):""":type root: TreeNode:rtype: int"""if not root:return 0return max(self.maxDepth(root.left),self.maxDepth(root.right))+1

c++代碼:

/*** 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:int maxDepth(TreeNode* root) {if(root==NULL){return 0;}return max(maxDepth(root->left),maxDepth(root->right))+1;} };

2-2：二叉樹的最小深度

思路;求的就是根節點到葉子節點的最小值

python代碼:

# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution:def minDepth(self, root: TreeNode) -> int:if root is None:return 0if root.left and root.right:return min(self.minDepth(root.left),self.minDepth(root.right))+1elif root.left:return self.minDepth(root.left)+1else:return self.minDepth(root.right)+1

?c++代碼:

/*** 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 minDepth(TreeNode* root) {if (root == nullptr){return 0;}if(root->left && root->right){return min(minDepth(root->left),minDepth(root->right))+1;}else if(root->left){return minDepth(root->left)+1;}else{return minDepth(root->right)+1;}} };

2-3.二叉樹的直徑

思路:遞歸函數用來獲取每一層深度，然后在分別對左右子樹深度求和，這里要注意的是最長直徑不一定過根節點，所有要用一個變量存儲遍歷每個節點時的最大直徑．

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def get_depth(self, node):if node is None:return 0l = self.get_depth(node.left)r = self.get_depth(node.right)self.max_value = max(self.max_value, l+r)return max(l,r)+1def diameterOfBinaryTree(self, root: TreeNode) -> int:self.max_value = 0if root is None:return 0self.get_depth(root)return self.max_value

c++實現:

/*** 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:int max_value=0;int help(TreeNode* node){if(!node){return 0;}int l = help(node->left);int r = help(node->right);max_value = max(max_value, l+r);return max(l,r)+1;}int diameterOfBinaryTree(TreeNode* root) {help(root);return max_value;} };

2-4.二叉樹中的最大路徑和

遞歸　主要是要找準遞歸終止條件和遞歸出口,終止條件就是節點為none自然返回值為0, 遞歸出口就是節點本身值+max(左節點增益值，右節點增益值)

# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution:def helper(self, node):if node is None:return 0left_gain = self.helper(node.left)right_gain = self.helper(node.right)self.max_gain = max(self.max_gain,left_gain+right_gain+node.val)return max(node.val+left_gain,node.val+right_gain,0)def maxPathSum(self, root: TreeNode) -> int:self.max_gain = float('-inf')self.helper(root)return self.max_gain

c++實現:

/*** 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 max_value=INT_MIN;int helper(TreeNode *node){if(!node){return 0;}int left_gain = helper(node->left);int right_gain = helper(node->right);max_value = max(max_value, node->val+left_gain+right_gain);return max(max(node->val+left_gain,0),node->val+right_gain);}int maxPathSum(TreeNode* root) {helper(root);return max_value;} };

2-5.路徑總和

1.遞歸法?

# Definition for a binary tree node. # class TreeNode(object): # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution(object):def hasPathSum(self, root, sum):""":type root: TreeNode:type sum: int:rtype: bool"""if not root:return Falseif not root.left and not root.right and root.val==sum:return Truesum -=root.valreturn self.hasPathSum(root.left,sum) or self.hasPathSum(root.right,sum)

c++實現:

/*** 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:bool hasPathSum(TreeNode* root, int targetSum) {if(root == nullptr){return false;}if (root->left == nullptr && root->right == nullptr && targetSum==root->val){return true;}targetSum -=root->val;return hasPathSum(root->left,targetSum) || hasPathSum(root->right,targetSum);} };

2.利用棧--DFS

class Solution(object):def hasPathSum(self, root, sum):""":type root: TreeNode:type sum: int:rtype: bool"""# # #遞歸終止條件 # if root is None:# return False# if root.left is None and root.right is None and root.val == sum:# return True# sum = sum - root.val# # print('===sum:', sum)# return self.hasPathSum(root.left, sum) or self.hasPathSum(root.right, sum) if not root:return Falsequene = [(root, root.val)]while quene:node,value = quene.pop()if node.left is None and node.right is None and value==sum:return Trueif node.left is not None:quene.append((node.left,value+node.left.val))if node.right is not None:quene.append((node.right,value+node.right.val)) # print('==quene:',quene)return False

3.利用隊列--BFS

class Solution(object):def hasPathSum(self, root, sum):""":type root: TreeNode:type sum: int:rtype: bool"""# # #遞歸終止條件 # if root is None:# return False# if root.left is None and root.right is None and root.val == sum:# return True# sum = sum - root.val# # print('===sum:', sum)# return self.hasPathSum(root.left, sum) or self.hasPathSum(root.right, sum) if not root:return Falsequene = [(root, root.val)]while quene:node,value = quene.pop(0)if node.left is None and node.right is None and value==sum:return Trueif node.left is not None:quene.append((node.left,value+node.left.val))if node.right is not None:quene.append((node.right,value+node.right.val)) # print('==quene:',quene)return False

2-6:路徑總和 II

思路：回溯　這種里面要調用兩層回溯的　　track就不要放在遞歸函數里面了

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def dfs(self, node, sum_):if node is None:return 0store = self.track.copy()self.track.append(node.val)# print('==self.track:', self.track)if node.left is None and node.right is None and sum_==node.val: self.res.append(self.track)sum_ -= node.valself.dfs(node.left, sum_)self.dfs(node.right, sum_)# self.track.pop()self.track = storedef pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:self.res = []self.track = []self.dfs(root, sum)return self.res

c++實現:

/*** 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:vector<vector<int>> res;vector<int> track;void dfs(TreeNode* root, int targetSum){if(root==nullptr){return ;}vector<int> store;store = track;track.push_back(root->val); if(root->left==nullptr && root->right==nullptr && targetSum==root->val){res.push_back(track);}targetSum -= root->val;dfs(root->left, targetSum);dfs(root->right, targetSum);track = store;}vector<vector<int>> pathSum(TreeNode* root, int targetSum) {dfs(root, targetSum);return res;} };

2-7:路徑總和 III

思路：用一個列表存儲從節點開始的數字和

# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right #用列表記錄從每一個節點開始的和 class Solution:def dfs(self, node, sum_list, sum):if node is None:return 0 sum_list = [num+node.val for num in sum_list]sum_list.append(node.val)for num in sum_list:if num==sum:self.res+=1self.dfs(node.left, sum_list, sum)self.dfs(node.right, sum_list, sum)def pathSum(self, root: TreeNode, sum: int) -> int:self.res = 0self.dfs(root, [], sum)return self.res

c++實現:

/*** 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 res;void dfs(TreeNode* node, vector<int> num_list, int sum){if(node == nullptr){return ;}for (int i=0; i<num_list.size(); i++){num_list[i] += node->val;} num_list.push_back(node->val);for(int i=0; i<num_list.size(); i++){if(num_list[i]==sum){res++;}}dfs(node->left, num_list, sum);dfs(node->right, num_list, sum);}int pathSum(TreeNode* root, int sum) {vector<int> num_list;dfs(root, num_list, sum);return res;} };

2-8.二叉樹的所有路徑

給定一個二叉樹，返回所有從根節點到葉子節點的路徑

思路：dfs

# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution:def dfs(self, node,path):if not node:returnpath +=str(node.val)if node.left is None and node.right is None:self.res.append(path)else:path+="->"self.dfs(node.left, path)self.dfs(node.right, path)def binaryTreePaths(self, root: TreeNode) -> List[str]:self.res = []self.dfs(root, "")return self.res

c++實現:

/*** 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:vector<string> res;void dfs(TreeNode* node, string path){if(node == nullptr){return ;}path+=to_string(node->val);if(node->left == nullptr && node->right == nullptr){res.push_back(path);}else{path+="->";dfs(node->left, path);dfs(node->right, path);}}vector<string> binaryTreePaths(TreeNode* root) {dfs(root, "");return res;} };

2-9.求根節點到葉節點數字之和

python:

# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution:def help(self, node, path):if node is None:returnpath += str(node.val)if node.left is None and node.right is None:self.res.append(path)else: self.help(node.left, path)self.help(node.right, path)def sumNumbers(self, root: TreeNode) -> int:self.res = []self.help(root, '')return sum(map(int, self.res))

ｃ++代碼:

/*** 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:vector<string> res;void help(TreeNode* node, string path){if(node == nullptr){return ;}path += to_string(node->val);if(node->left == nullptr && node->right == nullptr){res.push_back(path);}else{help(node->left, path);help(node->right, path);}}int sumNumbers(TreeNode* root) {help(root, "");int int_res;for(auto str_:res){int_res += atoi(str_.c_str());}return int_res;} };

3-1.合并二叉樹

思路:采用前序遍歷訪問二叉樹，如果節點其一為none，就返回另一個

1.遞歸法

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode:if t1 is None:return t2if t2 is None:return t1t1.val+=t2.valt1.left = self.mergeTrees(t1.left,t2.left)t1.right = self.mergeTrees(t1.right,t2.right)return t1

2.迭代法

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode:if t1 is None:return t2stack= [(t1,t2)]while stack:t = stack.pop()if t[0] is None or t[1] is None:continuet[0].val +=t[1].valif t[0].left is None:t[0].left = t[1].leftelse:stack.append((t[0].left, t[1].left))if t[0].right is None:t[0].right = t[1].rightelse:stack.append((t[0].right, t[1].right))return t1

c++實現:

/*** 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:TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {if(root1 == nullptr){return root2;}if(root2 == nullptr){return root1;}root1->val += root2->val;root1->left = mergeTrees(root1->left, root2->left);root1->right = mergeTrees(root1->right, root2->right);return root1;} };

3-2：翻轉二叉樹

思路:遞歸遍歷左右子樹進行交換即可

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def invertTree(self, root: TreeNode) -> TreeNode:if root is None:return Noneleft = self.invertTree(root.left)right = self.invertTree(root.right)root.left = rightroot.right = leftreturn root

c++實現:

/*** 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:TreeNode* invertTree(TreeNode* root) {if(root == nullptr){return nullptr;}TreeNode* left = invertTree(root->left);TreeNode* right = invertTree(root->right);root->left = right;root->right = left;return root;} };

3-3.檢查二叉樹平衡性

思路：遞歸求解節點左右分支的最長路徑，如果路徑之差絕對值大于1，就認為是非平衡。?

# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution:def depth(self, node):if node is None:return 0return max(self.depth(node.left), self.depth(node.right)) + 1def isBalanced(self, root: TreeNode) -> bool:if root is None:return Trueif abs(self.depth(root.left) - self.depth(root.right)) > 1:return Falsereturn self.isBalanced(root.left) and self.isBalanced(root.right)

c++實現:

/*** 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:int get_height(TreeNode* node){if(node == NULL){return 0;}return max(get_height(node->left), get_height(node->right))+1;}bool isBalanced(TreeNode* root) {if(root == NULL){return true;}int left_value = get_height(root->left);int right_value = get_height(root->right);// cout<<left_value<<endl;// cout<<right_value<<endl;if(abs(left_value-right_value)>1){return false;}return isBalanced(root->left) && isBalanced(root->right);} };

3-4.對稱二叉樹

1.解法1 bfs 對每個節點的左子樹和右子樹進行判斷相等

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def isSymmetric(self, root: TreeNode) -> bool:def check(t1,t2):if t1==None and t2==None:return Trueif t1==None or t2==None:return Falseif (t1.val != t2.val):return Falsereturn check(t1.left,t2.right) and check(t1.right,t2.left)return check(root,root)

c++實現:

/*** 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:bool dfs(TreeNode* t1, TreeNode* t2){if(t1==nullptr && t2==nullptr){return true;}if(t1==nullptr || t2==nullptr){return false;}return dfs(t1->left,t2->right) && dfs(t1->right,t2->left);}bool isSymmetric(TreeNode* root) {return dfs(root, root);} };

2.解法2 dfs ，首先對根節點左子樹進行前序遍歷并存儲值，對根節點右子樹的右分支進行遍歷在對左分支進行遍歷并存儲值，最后比較兩個列表的值。

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def isSymmetric(self, root: TreeNode) -> bool:if root==None:return Truedef leftsearch(t1, left):if t1==None:left.append(None)else:left.append(t1.val)leftsearch(t1.left,left)leftsearch(t1.right,left)def rightsearch(t2, right):if t2==None:right.append(None)else:right.append(t2.val)rightsearch(t2.right,right)rightsearch(t2.left,right)left = []right = []leftsearch(root.left, left)rightsearch(root.right, right)if left==right:return Trueelse:return False

3-5.相同的樹

思路：判斷節點 相等 判斷節點的值相等 在遞歸左右子樹

# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution:def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:if not p and not q:#兩個節點都為空return Trueif (not p and q) or (not q and p):#兩個節點只要有一個不為空return Falseif p.val != q.val:return Falsereturn self.isSameTree(p.left,q.left) and self.isSameTree(p.right,q.right)

c++實現:

/*** 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:bool isSameTree(TreeNode* p, TreeNode* q) {if(p==nullptr && q==nullptr){return true;}if(p==nullptr || q==nullptr){return false;}if(p->val != q->val){return false;}return isSameTree(p->left,q->left) && isSameTree(p->right,q->right);} };

3-6.左葉子之和

思路：判斷左葉子的條件：節點的左指針不為none,同時節點的左指針的左指針和節點的左指針的右指針為none

1.遞歸寫法

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def sumOfLeftLeaves(self, root: TreeNode) -> int:self.result = 0 def get_res(t):if t is None:return 0 if t is not None and t.left is not None and t.left.left is None and t.left.right is None:self.result = self.result + t.left.val get_res(t.left)get_res(t.right)get_res(root)return self.result

c++實現:

/*** 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:int res;void help(TreeNode* node){if(node == NULL){return ;}if(node->left !=NULL && node->left->left ==NULL && node->left->right ==NULL){res+=node->left->val;}help(node->left);help(node->right);}int sumOfLeftLeaves(TreeNode* root) {if(root == NULL){return 0;}help(root);return res;} };

2.迭代寫法

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def sumOfLeftLeaves(self, root: TreeNode) -> int:if root is None:return 0 stack = [root]res = 0while stack:node = stack.pop()if node is not None:if node.left is not None and node.left.left is None and node.left.right is None:res += node.left.valstack.append(node.left)stack.append(node.right)return res

4-1.從前序與中序遍歷序列構造二叉樹

思路：

終止條件:前序或中序數組為空．
根據前序數組第一個元素，拼出根節點，再將前序數組和中序數組分成兩半，遞歸的處理前序數組左邊和中序數組左邊，遞歸的處理前序數組右邊和中序數組右邊。

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode: # 遞歸終止條件 前序遍歷節點數或中序遍歷節點數為０if len(preorder)==0 or len(inorder)==0:return Noneroot = TreeNode(preorder[0])#根據前序遍歷特點創建根節點#再根據中序遍歷特點用根節點找出左右子樹的分界點mid_index = inorder.index(preorder[0])#再利用中序遍歷和前序遍歷的左子樹節點個數相等特點　構造根節點左子樹root.left = self.buildTree(preorder[1:mid_index+1],inorder[:mid_index])#再利用中序遍歷和前序遍歷的右子樹節點個數相等特點　構造根節點右子樹root.right = self.buildTree(preorder[mid_index+1:],inorder[mid_index+1:])return root

c++實現:

/*** 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:TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {if(preorder.empty() || preorder.empty()) {return nullptr;}TreeNode* root = new TreeNode(preorder[0]);int root_value = preorder[0];int middle = 0;for (int i=0;i<inorder.size();i++){if(inorder[i]==root_value){middle = i;break;}}vector<int> leftInorder(inorder.begin(), inorder.begin() + middle);vector<int> rightInorder(inorder.begin() + middle + 1, inorder.end());vector<int> leftPreorder(preorder.begin()+1, preorder.begin() + middle+1);vector<int> rightPreorder(preorder.begin() + middle + 1, preorder.end());root->left = buildTree(leftPreorder,leftInorder);root->right = buildTree(rightPreorder,rightInorder);return root;} };

4-2.從中序與后序遍歷序列構造二叉樹

/*** 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:TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {if(inorder.empty() || postorder.empty()){return nullptr;}TreeNode* root = new TreeNode(postorder[postorder.size()-1]);int root_value = postorder[postorder.size()-1];int middle = 0;for (int i=0; i<inorder.size(); i++){if(inorder[i] == root_value){middle = i;break;}}// cout<<"===middle:"<<middle<<endl;vector<int> left_inorder(inorder.begin(), inorder.begin() + middle);vector<int> right_inorder(inorder.begin() + middle + 1, inorder.end());vector<int> left_postorder(postorder.begin(), postorder.begin() + middle);vector<int> right_postorder(postorder.begin() + middle, postorder.end() - 1);root->left = buildTree(left_inorder, left_postorder);root->right = buildTree(right_inorder, right_postorder);return root;} };

?思路：和上一題類似

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:#遞歸終止條件if len(inorder)==0 or len(postorder)==0:return None#創建根節點root = TreeNode(postorder[-1])#根據中序遍歷獲取分離點mid_index = inorder.index(postorder[-1])# print('==mid_index:',mid_index)#獲取左子樹root.left = self.buildTree(inorder[:mid_index],postorder[:mid_index])#獲取右子樹root.right = self.buildTree(inorder[mid_index+1:],postorder[mid_index:-1])return root

c++實現:

/*** 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:TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {if(inorder.empty() || postorder.empty()){return nullptr;}TreeNode* root = new TreeNode(postorder[postorder.size()-1]);int root_value = postorder[postorder.size()-1];int middle = 0;for (int i=0; i<inorder.size(); i++){if(inorder[i] == root_value){middle = i;break;}}// cout<<"===middle:"<<middle<<endl;vector<int> left_inorder(inorder.begin(), inorder.begin() + middle);vector<int> right_inorder(inorder.begin() + middle + 1, inorder.end());vector<int> left_postorder(postorder.begin(), postorder.begin() + middle);vector<int> right_postorder(postorder.begin() + middle, postorder.end() - 1);root->left = buildTree(left_inorder, left_postorder);root->right = buildTree(right_inorder, right_postorder);return root;} };

由上面兩題可知對于前序遍歷：跟左右，中序遍歷：左跟右，后序遍歷左右跟；

采前序遍歷和中序遍歷，中序遍歷和后序遍歷都能通過根節點分離出左右，而前序遍歷和后序遍歷就不能，故而后者無法恢復出二叉樹．

4-3.二叉樹的序列化與反序列化

# Definition for a binary tree node. # class TreeNode(object): # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Codec:def serialize(self, root):"""Encodes a tree to a single string.:type root: TreeNode:rtype: str"""# return self.pre_order(root)# self.in_order(root)from collections import dequeres = []queue= [root]#deque([root])while queue:root = queue.pop(0)#left()if root:res.append(root.val)queue.extend([root.left, root.right])else:res.append('#')return str(res)def deserialize(self, data):"""Decodes your encoded data to tree.:type data: str:rtype: TreeNode"""# print(self.pre_rest, self.in_res)print(data)nodes = [(TreeNode(v) if v != '#' else None) for v in eval(data)]i, j, n = 0, 1, len(nodes)while j < n:if nodes[i]:nodes[i].left = nodes[j]j += 1nodes[i].right = nodes[j]j += 1i += 1return nodes[0] # Your Codec object will be instantiated and called as such: # ser = Codec() # deser = Codec() # ans = deser.deserialize(ser.serialize(root))

5-1.二叉搜索樹的最近公共祖先

思路：

1.從根節點開始遍歷樹
2.如果節點 p 和節點 q 都在右子樹上，那么以右孩子為根節點繼續 1 的操作
3.如果節點 p 和節點 q 都在左子樹上，那么以左孩子為根節點繼續 1 的操作
4.如果條件 2 和條件 3 都不成立，這就意味著我們已經找到p 和q 的公共祖先了

解法1:當成普通二叉樹

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':if root==p or root==q or root is None:return rootleft_node = self.lowestCommonAncestor(root.left,p,q)right_node = self.lowestCommonAncestor(root.right,p,q)if left_node is None:return right_nodeif right_node is None:return left_nodereturn root

解法2利用二叉搜索樹特點根節點值和左右子樹值大小的特點.遞歸法

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None #利用二叉搜索樹的特點 class Solution:def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':print('==root.val:', root.val)if root.val< min(p.val, q.val):#都大于根節點的值 將右孩子作為根節點return self.lowestCommonAncestor(root.right, p, q)elif root.val > max(p.val, q.val):#都小于根節點的值 將左孩子作為根節點return self.lowestCommonAncestor(root.left, p, q)else:#找到公共祖先return root

c++實現:

/*** 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) {if(root->val<min(p->val,q->val)){return lowestCommonAncestor(root->right,p,q);}if(root->val>max(p->val,q->val)){return lowestCommonAncestor(root->left,p,q);}return root;} };

解法3.迭代法

#利用二叉搜索樹的特點 class Solution:def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':node = rootwhile node:if node.val < min(p.val,q.val):node = node.rightelif node.val > max(p.val,q.val):node = node.leftelse:return node

5-2:二叉樹的最近公共祖先

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':if root is None or root==p or root==q:#遞歸終止條件　節點為空　或者節點等于p,q其中之一return rootleft = self.lowestCommonAncestor(root.left, p, q)#遍歷左子樹right = self.lowestCommonAncestor(root.right, p, q)#遍歷右子樹if left is None:#左子樹為空　就去右子樹　return rightif right is None:#右子樹為空　就去左子樹　return leftreturn root#左右子樹都不為空　說明找到了節點　

c++實現:

/*** 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) {if (root == NULL){return NULL;}if(root->val == p->val || root->val == q->val){return root;}TreeNode* left_node = lowestCommonAncestor(root->left,p,q);TreeNode* right_node = lowestCommonAncestor(root->right,p,q);if(left_node !=NULL && right_node!=NULL){return root;}if (left_node==NULL){return right_node;}return left_node;} };

5-3.二叉搜索樹中的搜索

思路：利用二叉樹特點

1.從根節點遍歷二叉樹

2.如果給定值小于跟節點值，根節點替換為右孩子節點，否則根節點替換為左孩子節點

1.遞歸法

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None #遞歸法 class Solution:def searchBST(self, root: TreeNode, val: int) -> TreeNode:if not root or root.val ==val:#截止條件return rootif root.val < val:return self.searchBST(root.right,val)else:return self.searchBST(root.left,val)

c++實現:

/*** 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:TreeNode* searchBST(TreeNode* root, int val) {if(root == nullptr){return root;}if(root->val == val){return root;}if(root->val > val){return searchBST(root->left,val);}else{return searchBST(root->right,val);}} };

2.迭代法

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None #迭代法 class Solution:def searchBST(self, root: TreeNode, val: int) -> TreeNode:while root is not None and root.val !=val:root = root.left if root.val >val else root.rightreturn root

5-4.把二叉搜索樹轉換為累加樹?

思路：其實就是逆中序遍歷，利用二叉搜索樹的特點，跟節點值更新為右孩子和根節點值之和，左孩子值更新為根節點與左孩子值之和。

1.迭代法：

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def convertBST(self, root: TreeNode) -> TreeNode:stack = []node = rootvalue = 0while stack or node:while node:#把跟節點與右子樹節點依次壓進棧 實現逆中序遍歷stack.append(node)node = node.rightprint('==stack:', stack)node = stack.pop()print('==node:',node)value += node.valnode.val = valueprint('==node.left:', node.left)node = node.leftreturn root

2.遞歸法：

其中res存儲逆中序遍歷(右根左)的值，便于查看

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:def helper(self, node):if node:self.helper(node.right)# self.res.append(node.val)self.value+=node.valnode.val = self.valueself.helper(node.left)def convertBST(self, root: TreeNode) -> TreeNode:# self.res =[]self.value = 0self.helper(root)return root

c++實現:

/*** 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 res = 0;void help(TreeNode* node){if(node == nullptr){return ;}help(node->right);res += node->val;node->val = res;help(node->left);}TreeNode* convertBST(TreeNode* root) {help(root);return root;} };

5-5.刪除二叉搜索樹中的節點

#思路：中序遍歷，如果值大于節點值，則去右子樹，否則去左子樹
#如果 找的的節點是葉子節點，則進行刪除置None即可
#如果找到的節點不是葉子節點，有右子樹，則用后繼節點(比當前節點值大的最小值)代替找到的節點，在將后繼節點置None
#如果找到的節點不是葉子節點，有左子樹，則用前驅節點(比當前節點值小的最大值)代替找到的節點，在將前驅節點置None?

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:#獲取節點的后繼節點(比當前節點大的最小值)def get_successor(self, node):node = node.rightwhile node.left:node = node.leftreturn node.val#獲取節點的前驅節點(比當前節點小的最大值)def get_pressor(self, node):node = node.leftwhile node.right:node = node.rightreturn node.valdef deleteNode(self, root: TreeNode, key: int) -> TreeNode:if root is None:return Noneif root.val<key:root.right = self.deleteNode(root.right, key)elif root.val>key:root.left = self.deleteNode(root.left, key)else:if root.left is None and root.right is None:#葉子節點root = None elif root.right:#要刪除的節點有右子樹 利用后繼節點root.val = self.get_successor(root)root.right = self.deleteNode(root.right,root.val)#刪除后繼節點else:#要刪除的節點有左子樹 利用前驅節點root.val = self.get_pressor(root)root.left = self.deleteNode(root.left,root.val)#刪除前驅節點 return root

c++實現:?

/*** 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 get_succesor(TreeNode* node){//得到后繼節點node = node->right;while(node->left != nullptr){node = node->left;}return node->val;}int get_pressor(TreeNode* node){node = node->left;while(node->right != nullptr){node = node->right;}return node->val;}TreeNode* deleteNode(TreeNode* root, int key) {if(root == nullptr){return nullptr;}if(root->val < key){root->right= deleteNode(root->right, key);}else if(root->val >key){root->left= deleteNode(root->left, key);}else{if(root->left == nullptr && root->right == nullptr){root = nullptr;}else if(root->right != nullptr){root->val = get_succesor(root);root->right = deleteNode(root->right, root->val);}else{root->val = get_pressor(root);root->left = deleteNode(root->left, root->val);}}return root;} };

5-6.不同的二叉搜索樹

思路:卡塔蘭數

將 1?(i?1) 序列作為左子樹，將 (i+1)?n 序列作為右子樹。接著我們可以按照同樣的方式遞歸構建左子樹和右子樹。

在上述構建的過程中，由于根的值不同，因此我們能保證每棵二叉搜索樹是唯一的.也就得到卡塔蘭數

class Solution(object):def numTrees(self, n):""":type n: int:rtype: int"""#狀態方程 和G(j-1) * G(n-j)dp = [0]*(n+1)#0 1樹都為1dp[0], dp[1] = 1, 1for i in range(2,n+1):for j in range(1,i+1):dp[i] += dp[j-1]*dp[i-j]# print('==dp:', dp)return dp[-1]

c++實現:

class Solution { public:int numTrees(int n) {vector<int> res(n+1,0); res[0] = 1;res[1] = 1;for (int i=2;i<n+1;i++){for (int j=1;j<i+1;j++){res[i] += res[j-1] * res[i-j];}}return res[n];} };

5-7.不同的二叉搜索樹 II

思路:

# Definition for a binary tree node. # class TreeNode(object): # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution(object):def generateTrees(self, n):""":type n: int:rtype: List[TreeNode]"""if n==0:return []def build_tree(left,right):if left > right:#遞歸終止條件 如果左邊計數大于右邊 說明要返回空值return [None]all_trees = []for i in range(left, right+1):left_trees = build_tree(left, i-1)right_trees = build_tree(i+1, right)for l in left_trees:#遍歷可能的左子樹for r in right_trees:#遍歷可能的右子樹cur_tree = TreeNode(i)#根節點cur_tree.left= lcur_tree.right = rall_trees.append(cur_tree)return all_treesres = build_tree(1,n)return res

5.8.驗證二叉搜索樹

思路1:遞歸處理右子樹節點和 左子樹節點的值和上下界限的大小

# Definition for a binary tree node. # class TreeNode(object): # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution(object):def isValidBST(self, root):""":type root: TreeNode:rtype: bool"""def helper(node, lower=float('-inf'), upper=float('inf')):if node is None:#遞歸終止條件 節點為Nonereturn Trueval = node.val#獲取節點值#如果節點值大于上界或者小于下界 ,返回falseif val >= upper or val <= lower :return False#遞歸右子樹 對于右子樹 具備下界if not helper(node.right, val, upper):return False#遞歸左子樹 對于左子樹 具備上界if not helper(node.left, lower, val):return Falsereturn Truereturn helper(root)

c++實現:

/*** 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:bool help(TreeNode* node, long long lower,long long upper){if(node == nullptr){return true;}if(node->val <= lower || node->val >= upper){return false;}if(!help(node->right, node->val, upper)){return false;}if(!help(node->left, lower, node->val)){return false;}return true;}bool isValidBST(TreeNode* root) {if(root == nullptr){return true;}return help(root, LONG_MIN, LONG_MAX);} };

思路2 :利用中序遍歷的特點,遍歷左子樹和根節點,如果值不滿足二叉搜索數特點就返回false.

# Definition for a binary tree node. # class TreeNode(object): # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution(object):def isValidBST(self, root):stack = []node = rootinorder_value = float('-inf')while stack or node:#出棧終止條件while node:#進棧stack.append(node)node = node.leftnode = stack.pop()#左節點# 如果中序遍歷得到的節點的值小于等于前一個 inorder_value，說明不是二叉搜索樹if node.val <=inorder_value:return Falseinorder_value = node.val node=node.rightreturn True

思路3:遞歸實現中序遍歷　左　跟　右　也就是遍歷的后一個節點值要大于上一個　否則不滿足二叉搜索樹特點

# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right #中序遍歷　左跟右 class Solution:def __init__(self):self.pre = float('-inf')def isValidBST(self, root: TreeNode) -> bool:if root is None:return Trueif not self.isValidBST(root.left):#先訪問左子樹return Falseif root.val<=self.pre:#在訪問當前節點return False;print('==before self.pre:',self.pre)self.pre = root.valprint('==after self.pre:',self.pre)return self.isValidBST(root.right)#在訪問右子樹

5.9將有序數組轉換為二叉搜索樹

思路:二分法

python代碼?

# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution:def help(self, left, right):if left > right:return Nonemid = left + (right - left) // 2root = TreeNode(self.nums[mid])root.left = self.help(left, mid - 1)root.right = self.help(mid + 1, right)return rootdef sortedArrayToBST(self, nums: List[int]) -> TreeNode: self.nums = numsreturn self.help(0, len(nums) - 1) # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution:def help(self, left, right):if left > right:return Nonemid = left + (right - left) // 2root = TreeNode(self.nums[mid])root.left = self.help(left, mid - 1)root.right = self.help(mid + 1, right)return rootdef sortedArrayToBST(self, nums: List[int]) -> TreeNode: self.nums = numsreturn self.help(0, len(nums) - 1)

總結

以上是生活随笔為你收集整理的二叉树的一些leetcode题目+python(c++)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。