二叉树类型OJ题篇1

二叉树类型题

1、左叶子之和

计算给定二叉树的所有左叶子之和

在这个二叉树中，有两个左叶子，分别是 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;
    }

2、二叉树的所有路径

给定一个二叉树，返回所有从根节点到叶子节点的路径

说明: 叶子节点是指没有子节点的节点

示例,输入:

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

3、翻转二叉树

翻转一棵二叉树

方法一：递归

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

4、二叉树的右视图

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值

示例
输入: [1,2,3,null,5,null,4]
输出: [1, 3, 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;
    }

5、重建二叉树

根据前序数列和中序数列构建二叉树

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,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;
    }

6、按’之’字形顺序打印二叉树

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推

比如：

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

7、序列化二叉树

请实现两个函数，分别用来序列化和反序列化二叉树

二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过某种符号表示空节点（#），以！表示一个结点值的结束(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;
};

8、二叉树搜索树的第 k 个节点

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

二叉树类型OJ题篇1

二叉树类型题

1、左叶子之和

2、二叉树的所有路径

3、翻转二叉树

4、二叉树的右视图

5、重建二叉树

6、按’之’字形顺序打印二叉树

7、序列化二叉树

8、二叉树搜索树的第 k 个节点

面試高頻 C++ 知識總結

容器適配器 stack、queue、priority_queue

深度優先搜索解題算法1

動態規劃解題算法3

c++編程題，電話號碼，求和

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

二叉树类型OJ题篇1

二叉树类型题

1、左叶子之和

2、二叉树的所有路径

3、翻转二叉树

4、二叉树的右视图

5、重建二叉树

6、按’之’字形顺序打印二叉树

7、序列化二叉树

8、 二叉树搜索树的第 k 个节点

8、二叉树搜索树的第 k 个节点