當(dāng)前位置：首頁(yè) > 编程语言 > python >内容正文

python

二叉树的一些leetcode题目+python(c++)

發(fā)布時(shí)間：2024/7/23 python 29 豆豆

生活随笔收集整理的這篇文章主要介紹了二叉树的一些leetcode题目+python(c++) 小編覺(jué)得挺不錯(cuò)的,現(xiàn)在分享給大家,幫大家做個(gè)參考.

二叉樹(shù)考點(diǎn)主要有:

1.三種遍歷方式,以及構(gòu)造二叉樹(shù)等；

2.求深度,最長(zhǎng)直徑，最長(zhǎng)路徑,公共祖先等等;

3.合并二叉樹(shù)，翻轉(zhuǎn)二叉樹(shù)，判斷平衡性,對(duì)稱性等;

4.從前序與中序構(gòu)造二叉樹(shù)，中序與后序構(gòu)造二叉樹(shù)，二叉樹(shù)序列化等;

5.二叉搜索樹(shù)

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++實(shí)現(xiàn):

思路２棧（迭代法）：

# 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++實(shí)現(xiàn):

1-2.N叉樹(shù)的前序遍歷

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++實(shí)現(xiàn):

/* // 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++實(shí)現(xiàn):

/* // 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;} }; */ //后進(jìn)左子樹(shù)先出左子樹(shù) 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++實(shí)現(xiàn):

思路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都是空的，說(shuō)明全查完了。while node: # 如果node是空的，說(shuō)明左邊沒(méi)子節(jié)點(diǎn)了。stack.append(node)node = node.leftnode = stack.pop() # 左邊沒(méi)子節(jié)點(diǎn)了就輸出棧頂?shù)墓?jié)點(diǎn)值，然后從它右邊的子節(jié)點(diǎn)繼續(xù)。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++實(shí)現(xiàn):

?思路２：棧（迭代法）

# 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:#右子樹(shù)為空或者為根節(jié)點(diǎn)值已經(jīng)遍歷過(guò)　prev已經(jīng)記錄右節(jié)點(diǎn)的值res.append(root.val)prev = rootroot = Noneelse:stack.append(root)root = root.rightreturn res

1-5.N叉樹(shù)的后序遍歷

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++實(shí)現(xiàn):

/* // 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.從上到下打印二叉樹(shù)

1.BFS:思路利用bfs將每一層節(jié)點(diǎn)進(jìn)行存儲(chǔ)?

# 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++實(shí)現(xiàn):

1-7.從上到下打印二叉樹(shù) II

思路：從跟節(jié)點(diǎn)開(kāi)始一層一層遍歷

1.遞歸法：要注意的是判斷節(jié)點(diǎn)是同一層，此時(shí)可以傳入一個(gè)level參數(shù)用于控制層數(shù)

# 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++實(shí)現(xiàn):

/*** 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.從上到下打印二叉樹(shù) III

1.思路BFS :將每一層節(jié)點(diǎn)存入隊(duì)列進(jìn)行遍歷,對(duì)奇數(shù)層進(jìn)行逆序加入即可

# 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++實(shí)現(xiàn):

/*** 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.二叉樹(shù)的鋸齒形層次遍歷

思路:將每一層的結(jié)果進(jìn)行保存,最后在奇數(shù)層反轉(zhuǎn)即可

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.遞增順序查找樹(shù)

思路:中序遍歷獲取每個(gè)節(jié)點(diǎn)的值,在利用值構(gòu)建樹(shù)?

# 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)#構(gòu)建樹(shù)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++實(shí)現(xiàn):

?1-11.?二叉樹(shù)的右視圖

思路：每一層進(jìn)行遍歷存儲(chǔ)結(jié)果,將每一層的右側(cè)結(jié)果進(jìn)行輸出即可。

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++實(shí)現(xiàn):

/*** 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. 找樹(shù)左下角的值

思路: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++:

2-1.二叉樹(shù)的深度

遞歸: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：二叉樹(shù)的最小深度

思路;求的就是根節(jié)點(diǎn)到葉子節(jié)點(diǎn)的最小值

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++代碼:

2-3.二叉樹(shù)的直徑

思路:遞歸函數(shù)用來(lái)獲取每一層深度，然后在分別對(duì)左右子樹(shù)深度求和，這里要注意的是最長(zhǎng)直徑不一定過(guò)根節(jié)點(diǎn)，所有要用一個(gè)變量存儲(chǔ)遍歷每個(gè)節(jié)點(diǎn)時(shí)的最大直徑．

# 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++實(shí)現(xiàn):

/*** 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.二叉樹(shù)中的最大路徑和

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

# 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++實(shí)現(xiàn):

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++實(shí)現(xiàn):

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.利用隊(duì)列--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

思路：回溯　這種里面要調(diào)用兩層回溯的　　track就不要放在遞歸函數(shù)里面了

# 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++實(shí)現(xiàn):

/*** 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

思路：用一個(gè)列表存儲(chǔ)從節(jié)點(diǎn)開(kāi)始的數(shù)字和

# 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 #用列表記錄從每一個(gè)節(jié)點(diǎn)開(kāi)始的和 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++實(shí)現(xiàn):

2-8.二叉樹(shù)的所有路徑

給定一個(gè)二叉樹(shù)，返回所有從根節(jié)點(diǎn)到葉子節(jié)點(diǎn)的路徑

思路：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++實(shí)現(xiàn):

2-9.求根節(jié)點(diǎn)到葉節(jié)點(diǎn)數(shù)字之和

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))

ｃ++代碼:

3-1.合并二叉樹(shù)

思路:采用前序遍歷訪問(wèn)二叉樹(shù)，如果節(jié)點(diǎn)其一為none，就返回另一個(gè)

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++實(shí)現(xiàn):

3-2：翻轉(zhuǎn)二叉樹(shù)

思路:遞歸遍歷左右子樹(shù)進(jìn)行交換即可

# 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++實(shí)現(xiàn):

3-3.檢查二叉樹(shù)平衡性

思路：遞歸求解節(jié)點(diǎn)左右分支的最長(zhǎng)路徑，如果路徑之差絕對(duì)值大于1，就認(rèn)為是非平衡。?

# 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++實(shí)現(xiàn):

/*** 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.對(duì)稱二叉樹(shù)

1.解法1 bfs 對(duì)每個(gè)節(jié)點(diǎn)的左子樹(shù)和右子樹(shù)進(jìn)行判斷相等

# 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++實(shí)現(xiàn):

2.解法2 dfs ，首先對(duì)根節(jié)點(diǎn)左子樹(shù)進(jìn)行前序遍歷并存儲(chǔ)值，對(duì)根節(jié)點(diǎn)右子樹(shù)的右分支進(jìn)行遍歷在對(duì)左分支進(jìn)行遍歷并存儲(chǔ)值，最后比較兩個(gè)列表的值。

# 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.相同的樹(shù)

思路：判斷節(jié)點(diǎn) 相等判斷節(jié)點(diǎn)的值相等在遞歸左右子樹(shù)

# 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:#兩個(gè)節(jié)點(diǎn)都為空return Trueif (not p and q) or (not q and p):#兩個(gè)節(jié)點(diǎn)只要有一個(gè)不為空return Falseif p.val != q.val:return Falsereturn self.isSameTree(p.left,q.left) and self.isSameTree(p.right,q.right)

c++實(shí)現(xiàn):

3-6.左葉子之和

思路：判斷左葉子的條件：節(jié)點(diǎn)的左指針不為none,同時(shí)節(jié)點(diǎn)的左指針的左指針和節(jié)點(diǎn)的左指針的右指針為none

1.遞歸寫(xiě)法

# 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++實(shí)現(xiàn):

/*** 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.迭代寫(xiě)法

# 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.從前序與中序遍歷序列構(gòu)造二叉樹(shù)

思路：

終止條件:前序或中序數(shù)組為空．
根據(jù)前序數(shù)組第一個(gè)元素，拼出根節(jié)點(diǎn)，再將前序數(shù)組和中序數(shù)組分成兩半，遞歸的處理前序數(shù)組左邊和中序數(shù)組左邊，遞歸的處理前序數(shù)組右邊和中序數(shù)組右邊。

# 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: # 遞歸終止條件前序遍歷節(jié)點(diǎn)數(shù)或中序遍歷節(jié)點(diǎn)數(shù)為０if len(preorder)==0 or len(inorder)==0:return Noneroot = TreeNode(preorder[0])#根據(jù)前序遍歷特點(diǎn)創(chuàng)建根節(jié)點(diǎn)#再根據(jù)中序遍歷特點(diǎn)用根節(jié)點(diǎn)找出左右子樹(shù)的分界點(diǎn)mid_index = inorder.index(preorder[0])#再利用中序遍歷和前序遍歷的左子樹(shù)節(jié)點(diǎn)個(gè)數(shù)相等特點(diǎn)　構(gòu)造根節(jié)點(diǎn)左子樹(shù)root.left = self.buildTree(preorder[1:mid_index+1],inorder[:mid_index])#再利用中序遍歷和前序遍歷的右子樹(shù)節(jié)點(diǎn)個(gè)數(shù)相等特點(diǎn)　構(gòu)造根節(jié)點(diǎn)右子樹(shù)root.right = self.buildTree(preorder[mid_index+1:],inorder[mid_index+1:])return root

c++實(shí)現(xiàn):

/*** 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.從中序與后序遍歷序列構(gòu)造二叉樹(shù)

/*** 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#創(chuàng)建根節(jié)點(diǎn)root = TreeNode(postorder[-1])#根據(jù)中序遍歷獲取分離點(diǎn)mid_index = inorder.index(postorder[-1])# print('==mid_index:',mid_index)#獲取左子樹(shù)root.left = self.buildTree(inorder[:mid_index],postorder[:mid_index])#獲取右子樹(shù)root.right = self.buildTree(inorder[mid_index+1:],postorder[mid_index:-1])return root

c++實(shí)現(xiàn):

/*** 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;} };

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

采前序遍歷和中序遍歷，中序遍歷和后序遍歷都能通過(guò)根節(jié)點(diǎn)分離出左右，而前序遍歷和后序遍歷就不能，故而后者無(wú)法恢復(fù)出二叉樹(shù)．

4-3.二叉樹(shù)的序列化與反序列化

# 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.二叉搜索樹(shù)的最近公共祖先

思路：

1.從根節(jié)點(diǎn)開(kāi)始遍歷樹(shù)
2.如果節(jié)點(diǎn) p 和節(jié)點(diǎn) q 都在右子樹(shù)上，那么以右孩子為根節(jié)點(diǎn)繼續(xù) 1 的操作
3.如果節(jié)點(diǎn) p 和節(jié)點(diǎn) q 都在左子樹(shù)上，那么以左孩子為根節(jié)點(diǎn)繼續(xù) 1 的操作
4.如果條件 2 和條件 3 都不成立，這就意味著我們已經(jīng)找到p 和q 的公共祖先了

解法1:當(dāng)成普通二叉樹(shù)

解法2利用二叉搜索樹(shù)特點(diǎn)根節(jié)點(diǎn)值和左右子樹(shù)值大小的特點(diǎn).遞歸法

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None #利用二叉搜索樹(shù)的特點(diǎn) 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):#都大于根節(jié)點(diǎn)的值將右孩子作為根節(jié)點(diǎn)return self.lowestCommonAncestor(root.right, p, q)elif root.val > max(p.val, q.val):#都小于根節(jié)點(diǎn)的值將左孩子作為根節(jié)點(diǎn)return self.lowestCommonAncestor(root.left, p, q)else:#找到公共祖先return root

c++實(shí)現(xiàn):

/*** 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.迭代法

#利用二叉搜索樹(shù)的特點(diǎn) 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:二叉樹(shù)的最近公共祖先

# 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:#遞歸終止條件　節(jié)點(diǎn)為空　或者節(jié)點(diǎn)等于p,q其中之一return rootleft = self.lowestCommonAncestor(root.left, p, q)#遍歷左子樹(shù)right = self.lowestCommonAncestor(root.right, p, q)#遍歷右子樹(shù)if left is None:#左子樹(shù)為空　就去右子樹(shù)　return rightif right is None:#右子樹(shù)為空　就去左子樹(shù)　return leftreturn root#左右子樹(shù)都不為空　說(shuō)明找到了節(jié)點(diǎn)　

c++實(shí)現(xiàn):

/*** 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.二叉搜索樹(shù)中的搜索

思路：利用二叉樹(shù)特點(diǎn)

1.從根節(jié)點(diǎn)遍歷二叉樹(shù)

2.如果給定值小于跟節(jié)點(diǎn)值，根節(jié)點(diǎn)替換為右孩子節(jié)點(diǎn)，否則根節(jié)點(diǎn)替換為左孩子節(jié)點(diǎn)

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++實(shí)現(xiàn):

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.把二叉搜索樹(shù)轉(zhuǎn)換為累加樹(shù)?

思路：其實(shí)就是逆中序遍歷，利用二叉搜索樹(shù)的特點(diǎn)，跟節(jié)點(diǎn)值更新為右孩子和根節(jié)點(diǎn)值之和，左孩子值更新為根節(jié)點(diǎn)與左孩子值之和。

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:#把跟節(jié)點(diǎn)與右子樹(shù)節(jié)點(diǎn)依次壓進(jìn)棧實(shí)現(xiàn)逆中序遍歷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存儲(chǔ)逆中序遍歷(右根左)的值，便于查看

# 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++實(shí)現(xiàn):

5-5.刪除二叉搜索樹(shù)中的節(jié)點(diǎn)

#思路：中序遍歷，如果值大于節(jié)點(diǎn)值，則去右子樹(shù)，否則去左子樹(shù)
#如果找的的節(jié)點(diǎn)是葉子節(jié)點(diǎn)，則進(jìn)行刪除置None即可
#如果找到的節(jié)點(diǎn)不是葉子節(jié)點(diǎn)，有右子樹(shù)，則用后繼節(jié)點(diǎn)(比當(dāng)前節(jié)點(diǎn)值大的最小值)代替找到的節(jié)點(diǎn)，在將后繼節(jié)點(diǎn)置None
#如果找到的節(jié)點(diǎn)不是葉子節(jié)點(diǎn)，有左子樹(shù)，則用前驅(qū)節(jié)點(diǎn)(比當(dāng)前節(jié)點(diǎn)值小的最大值)代替找到的節(jié)點(diǎn)，在將前驅(qū)節(jié)點(diǎn)置None?

# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = Noneclass Solution:#獲取節(jié)點(diǎn)的后繼節(jié)點(diǎn)(比當(dāng)前節(jié)點(diǎn)大的最小值)def get_successor(self, node):node = node.rightwhile node.left:node = node.leftreturn node.val#獲取節(jié)點(diǎn)的前驅(qū)節(jié)點(diǎn)(比當(dāng)前節(jié)點(diǎn)小的最大值)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:#葉子節(jié)點(diǎn)root = None elif root.right:#要?jiǎng)h除的節(jié)點(diǎn)有右子樹(shù) 利用后繼節(jié)點(diǎn)root.val = self.get_successor(root)root.right = self.deleteNode(root.right,root.val)#刪除后繼節(jié)點(diǎn)else:#要?jiǎng)h除的節(jié)點(diǎn)有左子樹(shù) 利用前驅(qū)節(jié)點(diǎn)root.val = self.get_pressor(root)root.left = self.deleteNode(root.left,root.val)#刪除前驅(qū)節(jié)點(diǎn) return root

c++實(shí)現(xiàn):?

/*** 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){//得到后繼節(jié)點(diǎn)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.不同的二叉搜索樹(shù)

思路:卡塔蘭數(shù)

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

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

class Solution(object):def numTrees(self, n):""":type n: int:rtype: int"""#狀態(tài)方程和G(j-1) * G(n-j)dp = [0]*(n+1)#0 1樹(shù)都為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++實(shí)現(xiàn):

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.不同的二叉搜索樹(shù) 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:#遞歸終止條件如果左邊計(jì)數(shù)大于右邊說(shuō)明要返回空值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:#遍歷可能的左子樹(shù)for r in right_trees:#遍歷可能的右子樹(shù)cur_tree = TreeNode(i)#根節(jié)點(diǎn)cur_tree.left= lcur_tree.right = rall_trees.append(cur_tree)return all_treesres = build_tree(1,n)return res

5.8.驗(yàn)證二叉搜索樹(shù)

思路1:遞歸處理右子樹(shù)節(jié)點(diǎn)和左子樹(shù)節(jié)點(diǎn)的值和上下界限的大小

# 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:#遞歸終止條件節(jié)點(diǎn)為Nonereturn Trueval = node.val#獲取節(jié)點(diǎn)值#如果節(jié)點(diǎn)值大于上界或者小于下界 ,返回falseif val >= upper or val <= lower :return False#遞歸右子樹(shù) 對(duì)于右子樹(shù) 具備下界if not helper(node.right, val, upper):return False#遞歸左子樹(shù) 對(duì)于左子樹(shù) 具備上界if not helper(node.left, lower, val):return Falsereturn Truereturn helper(root)

c++實(shí)現(xiàn):

思路2 :利用中序遍歷的特點(diǎn),遍歷左子樹(shù)和根節(jié)點(diǎn),如果值不滿足二叉搜索數(shù)特點(diǎn)就返回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:#進(jìn)棧stack.append(node)node = node.leftnode = stack.pop()#左節(jié)點(diǎn)# 如果中序遍歷得到的節(jié)點(diǎn)的值小于等于前一個(gè) inorder_value，說(shuō)明不是二叉搜索樹(shù)if node.val <=inorder_value:return Falseinorder_value = node.val node=node.rightreturn True

思路3:遞歸實(shí)現(xiàn)中序遍歷　左　跟　右　也就是遍歷的后一個(gè)節(jié)點(diǎn)值要大于上一個(gè)　否則不滿足二叉搜索樹(shù)特點(diǎn)

# 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):#先訪問(wèn)左子樹(shù)return Falseif root.val<=self.pre:#在訪問(wèn)當(dāng)前節(jié)點(diǎn)return False;print('==before self.pre:',self.pre)self.pre = root.valprint('==after self.pre:',self.pre)return self.isValidBST(root.right)#在訪問(wèn)右子樹(shù)

5.9將有序數(shù)組轉(zhuǎn)換為二叉搜索樹(shù)

思路:二分法

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)

總結(jié)

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

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。

上一篇：吴恩达《机器学习》学习笔记十二——机器学
下一篇： Python文件拷贝函数