计算给定二叉树的所有左叶子之和
3
/ \
9 20
/ \
15 7
在这个二叉树中,有两个左叶子,分别是 9 和 15,所以返回 24
方法一:递归
def sumOfLeftLeaves(self, root: TreeNode) -> int:
if not root:
return 0
# 判断左子树是否符合条件
if root.left and not root.left.left and not root.left.right:
return root.left.val + self.sumOfLeftLeaves(root.right)
# 进行递归
return self.sumOfLeftLeaves(root.left) + self.sumOfLeftLeaves(root.right)
方法二:非递归
用一个队列对二叉树进行层序遍历,如果是左子树的叶子节点,则加入返回变量中
int sumOfLeftLeaves(TreeNode* root) {
queue<TreeNode*>q;
if(root == nullptr){
return 0;
}
q.push(root);
int ans = 0;
while(!q.empty()){
TreeNode* temp = q.front();
q.pop();
if(temp->left && temp->left->left == nullptr
&& temp->left->right == nullptr){
ans+=temp->left->val;
}
if(temp->left){
q.push(temp->left);
}
if(temp->right){
q.push(temp->right);
}
}
return ans;
}
给定一个二叉树,返回所有从根节点到叶子节点的路径
说明: 叶子节点是指没有子节点的节点
示例,输入:
1
/ \
2 3
\
5
输出: ["1->2->5", "1->3"]
方法一:递归
先往左子树搜,再往右子树搜,记录访问过的节点
停止的条件是到了叶子节点,即该节点没有孩子节点了,这时候进行插入,然后把它用 ->
分割开来
def binaryTreePaths(self, root: TreeNode) -> List[str]:
res = []
if not root:
return res
def dfs(root,path):
if not root.left and not root.right:
res.append('->'.join(path+[str(root.val)]))
if root.left:
dfs(root.left,path+[str(root.val)])
if root.right:
dfs(root.right,path+[str(root.val)])
dfs(root,[])
return res
C++ 版本:思路基本一致
void dfs(TreeNode* root,string str,vector<string>&res){
if(root->left == NULL && root->right==NULL){
str += to_string(root->val);
res.push_back(str);
return;
}
str +=to_string(root->val) + "->";
if (root->left){
dfs(root->left,str,res);
}
if (root->right){
dfs(root->right,str,res);
}
}
vector<string> binaryTreePaths(TreeNode* root) {
vector<string>res;
if(root == NULL){
return res;
}
string str = "";
dfs(root,str,res);
return res;
}
方法二:非递归,利用栈
vector<string> binaryTreePaths(TreeNode* root) {
vector<string> ans;
if(root==NULL) {
return ans;
}
TreeNode* p=root;
stack<pair<TreeNode*,string>> s;
string str;
while(!s.empty() || p){
while(p){
if(p==root){
str=str+to_string(p->val);
}else{
str=str+"->"+to_string(p->val);
}
s.push(pair<TreeNode*,string>(p,str));
p=p->left;
}
p=s.top().first;
str=s.top().second;
s.pop();
if(p->right==NULL&&p->left==NULL)
ans.push_back(str);
p=p->right;
}
return ans;
}
非递归,利用队列
vector<string> binaryTreePaths(TreeNode* root) {
vector<string>res;
if(root == nullptr){
return res;
}
queue<pair<TreeNode*,string>>q;
q.push(pair<TreeNode*,string>\
(root,to_string(root->val)));
while(!q.empty()){
TreeNode* node = q.front().first;
string path = q.front().second;
q.pop();
if(node->left == nullptr &&
node->right == nullptr){
res.push_back(path);
}
if(node->left){
q.push(pair<TreeNode*,string>\
(node->left,path + "->"+to_string\
(node->left->val)));
}
if(node->right){
q.push(pair<TreeNode*,string>\
(node->right,path + "->"+to_string\
(node->right->val)));
}
}
return res;
}
翻转一棵二叉树
方法一:递归
def invertTree(self, root: TreeNode) -> TreeNode:
if root:
root.left,root.right = self.invertTree(root.right),self.invertTree(root.left)
return root
C++ 版本
TreeNode* invertTree(TreeNode root) {
if (root == null) {
return null;
}
TreeNode* temp = root->left;
root->left = invertTree(root->right);
root->right = invertTree(temp);
return root;
}
方法二 :非递归,利用一个队列进行迭代
TreeNode* invertTree(TreeNode* root) {
if(root==nullptr){
return nullptr;
}
queue<TreeNode*>que;
que.push(root);
while(!que.empty()){
TreeNode* cur = que.front();
que.pop();
TreeNode* temp = cur->left;
cur->left = cur->right;
cur->right = temp;
if(cur->left){
que.push(cur->left);
}
if(cur->right){
que.push(cur->right);
}
}
return root;
}
给定一棵二叉树,想象自己站在它的右侧,按照从顶部到底部的顺序,返回从右侧所能看到的节点值
示例
输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
1
/ \
2 3
\ \
5 4
思路:其实就是个层次遍历,然后把每层的最后一个节点附加到返回列表中。
def rightSideView(self, root: TreeNode) -> List[int]:
if not root:
return []
temp = [root]
res = []
while temp:
res.append(temp[-1].val)
temp = [kid for node in temp for kid in [node.left,node.right]if kid]
return res
C++版本
vector<int> rightSideView(TreeNode* root) {
vector<int>res;
if(!root){
return res;
}
queue<TreeNode*>q;
q.push(root);
while (!q.empty()){
int size = q.size();
res.push_back(q.front()->val);
while (size--){
TreeNode* temp = q.front();
q.pop();
if (temp->right){
q.push(temp->right);
}
if (temp->left){
q.push(temp->left);
}
}
}
return res;
}
根据前序数列和中序数列构建二叉树
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
输出
3
/ \
9 20
/ \
15 7
思路:前序遍历的第一个节点是 root 根节点,根据这个根节点在中序遍历中分成左子树和右子树,然后递归实现构建二叉树
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
int end = preorder.size()-1;
return build(preorder,inorder,0,0,end);
}
TreeNode* build(vector<int>& preorder, vector<int>& inorder,\
int root,int start,int end)
{
if(start>end){
return nullptr;
}
TreeNode* tree = new TreeNode(preorder[root]);
int i = start;
while(i<end && preorder[root] != inorder[i]){
++i;
}
tree->left = build(preorder,inorder,root+1,start,i-1);
tree->right = build(preorder,inorder,root+1+i-start,i+1,end);
return tree;
}
python 写法
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if not preorder:
return None
local = inorder.index(preorder[0])
root = TreeNode(preorder[0])
root.left = self.buildTree(preorder[1:local+1],inorder[:local])
root.right = self.buildTree(preorder[local+1:],inorder[local+1:])
return root
可以对中序列表设置一个 unordered_map 容器,方便bianli
unordered_map<int, int> mp;
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
for (int i = 0; i < inorder.size(); i++) {
mp[inorder[i]] = i;
}
return dfs(preorder, 0, preorder.size()-1, inorder, 0, inorder.size()-1);
}
TreeNode* dfs(const vector<int>& preorder, int pl, int pr, const vector<int>& inorder, int il, int ir) {
if (pl > pr) return NULL;
TreeNode *root = new TreeNode(preorder[pl]);
int idx = mp[root->val];
int cntL = idx - il;
root->left = dfs(preorder, pl + 1, pl + cntL, inorder, il, idx-1);
root->right = dfs(preorder, pl + cntL + 1, pr, inorder, idx+1, ir);
return root;
}
如果上面代码不好理解,那这个应该比较简单点
TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
if(vin.size()==0){
return 0;
}
// 定义四个数组
vector<int>pre_left,pre_right,vin_left,vin_right;
// 只有下面这一行代码是核心,其余都是准备工作
TreeNode* root = new TreeNode(pre[0]);
int temp = 0;
for(int i = 0;i < vin.size();++i){
if(vin[i] == pre[0]){
temp = i;
break;
}
}
for(int i = 0;i < temp;++i){
pre_left.push_back(pre[i+1]);
vin_left.push_back(vin[i]);
}
for(int i = temp+1;i < vin.size();++i){
pre_right.push_back(pre[i]);
vin_right.push_back(vin[i]);
}
root->left = reConstructBinaryTree(pre_left,vin_left);
root->right = reConstructBinaryTree(pre_right,vin_right);
return root;
}
请实现一个函数按照之字形打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右至左的顺序打印,第三行按照从左到右的顺序打印,其他行以此类推
比如:
1
/ \
2 3
/ \ / \
4 5 6 7
首先打印1,然后打印 3,2,然后打印4,5,6,7
规则就是,奇数行从左往右,偶数行从右往左
利用两个栈进行交换保存,虽然代码看起来挺多,但还是比较好理解的
vector<vector<int> > Print(TreeNode* pRoot) {
vector<vector<int>>res;
if(pRoot == nullptr){
return res;
}
// 定义两个栈,分别保存奇数行和偶数行
stack<TreeNode*>s1;
stack<TreeNode*>s2;
vector<int>temp;// 临时数组
temp.push_back(pRoot->val);
res.push_back(temp);
s1.push(pRoot);
temp.clear();
while(!s1.empty() || !s2.empty()){
while(!s1.empty()){
// 遍历 s1 栈,每遍历一个弹出一个
TreeNode* node = s1.top();
s1.pop();
if(node->right){
s2.push(node->right);
temp.push_back(node->right->val);
}
if(node->left){
s2.push(node->left);
temp.push_back(node->left->val);
}
}
// 最后插入完后,要情况一下
if(!temp.empty()){
res.push_back(temp);
temp.clear();
}
while(!s2.empty()){
// 遍历 s2 栈,每遍历一个弹出一个
TreeNode* cur = s2.top();
s2.pop();
if(cur->left){
s1.push(cur->left);
temp.push_back(cur->left->val);
}
if(cur->right){
s1.push(cur->right);
temp.push_back(cur->right->val);
}
}
// 最后插入完后,要情况一下
if(!temp.empty()){
res.push_back(temp);
temp.clear();
}
}
return res;
}
方法二:
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>>res;
if(root == nullptr){
return res;
}
queue<TreeNode*>q;
q.push(root);
bool isLeft = false;
while(!q.empty()){
int size = q.size();
vector<int>temp;
for(int i = 0;i<size;++i){
TreeNode* node = q.front();
q.pop();
temp.push_back(node->val);
if(node->left){
q.push(node->left);
}
if(node->right){
q.push(node->right);
}
}
isLeft = !isLeft;
if(!isLeft){
res.push_back(vector<int>(temp.rbegin(),temp.rend()));
}else{
res.push_back(temp);
}
}
return res;
}
};
请实现两个函数,分别用来序列化和反序列化二叉树
二叉树的序列化是指:把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串,从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改,序列化的结果是一个字符串,序列化时通过 某种符号表示空节点(#),以 ! 表示一个结点值的结束(value!)
二叉树的反序列化是指:根据某种遍历顺序得到的序列化字符串结果str,重构二叉树
class Solution {
public:
char* Serialize(TreeNode *root) {
buf.clear();
SerializePre(root);
int size = buf.size();
int* res = new int[size];
for(int i = 0;i < size;++i){
res[i] = buf[i];
}
return (char*)res;
}
TreeNode* Deserialize(char *str) {
int* p = (int*)str;
return DeserializePre(p);
}
private:
// 进行前序遍历,序列化二叉树
void SerializePre(TreeNode *root){
if(root == nullptr){
buf.push_back(0xFFFFFFFF);
}else{
buf.push_back(root->val);
SerializePre(root->left);
SerializePre(root->right);
}
}
// 反序列化二叉树
TreeNode* DeserializePre(int* &p){
if(*p == 0xFFFFFFFF){
p++;
return nullptr;
}
TreeNode* res = new TreeNode(*p);
p++;
res->left = DeserializePre(p);
res->right = DeserializePre(p);
return res;
}
private:
vector<int>buf;
};
TreeNode* res = nullptr;
int count = 0;
TreeNode* KthNode(TreeNode* pRoot, int k){
if(pRoot == nullptr || k < 1){
return nullptr;
}
count = k;
KthNodeIn(pRoot);
return res;
}
void KthNodeIn(TreeNode* pRoot){
if(pRoot == nullptr){
return;
}
KthNodeIn(pRoot->left);
if(--count ==0){
res = pRoot;
}
KthNodeIn(pRoot->right);
}