树

1.重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* reConstructBinaryTree2(vector<int> pre, vector<int> vin, int startP, int endP, int startV, int endV) {
        if(pre.size() == 0 || vin.size() == 0) return NULL;
        if(startP > endP || startV > endV) return NULL;
        TreeNode* root = new TreeNode(pre[startP]);
        for(int i = startV; i <= endV; i++){
            if(vin[i] == pre[startP]){
                root->left = reConstructBinaryTree2(pre, vin, startP+1, startP+i-startV, startV, i-1);
                root->right = reConstructBinaryTree2(pre, vin, startP+i-startV+1, endP, i+1, endV);
            }
        }
        return root;
    }

    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        return reConstructBinaryTree2(pre, vin, 0, pre.size()-1, 0, vin.size()-1);
    }
};

 

2.树的子结构

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        if(!pRoot1 || !pRoot2) return false;
        bool result = false;
        if(pRoot1->val == pRoot2->val){
            result = DoesTree1HasTree2(pRoot1, pRoot2);
        }
        if(!result){
            result = HasSubtree(pRoot1->left, pRoot2) || HasSubtree(pRoot1->right, pRoot2);
        }
        return result;
    }
    
    bool DoesTree1HasTree2(TreeNode* pRoot1, TreeNode* pRoot2){
        if(pRoot2 == NULL) return true;
        if(pRoot1 == NULL) return false;
        if(pRoot1->val == pRoot2->val){
            return DoesTree1HasTree2(pRoot1->left, pRoot2->left) 
                && DoesTree1HasTree2(pRoot1->right, pRoot2->right);
        }
        return false;
    }
};

需要注意的点：

1）是否从根节点开始；

2）是否从起点到终点都相等。

 

3.二叉树的镜像

题目描述

操作给定的二叉树，将其变换为源二叉树的镜像。

输入描述:

二叉树的镜像定义：源二叉树 
    	    8
    	   /  \
    	  6   10
    	 / \  / \
    	5  7 9 11
    	镜像二叉树
    	    8
    	   /  \
    	  10   6
    	 / \  / \
    	11 9 7  5

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    void Mirror(TreeNode *pRoot) {
        if(pRoot == NULL) return;
        swap(pRoot->left, pRoot->right);
        Mirror(pRoot->left);
        Mirror(pRoot->right);
    }
};

 

4.二叉搜索树的后序遍历序列

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        if(sequence.size() == 0) return false;
        vector<int> leftSeq;
        vector<int> rightSeq;
        int i = 0;
        int n = sequence.size();
        for(; i < n-1; i++){
            if(sequence[i] < sequence[n-1])
                leftSeq.push_back(sequence[i]);
            else
                break;
        }
        for(; i < n-1; i++){
            if(sequence[i] > sequence[n-1])
                rightSeq.push_back(sequence[i]);
            else
                return false;
        }
        
        bool left = true;
        bool right = true;
        if(!leftSeq.empty()) left = VerifySquenceOfBST(leftSeq);
        if(!rightSeq.empty()) right = VerifySquenceOfBST(rightSeq);
        return left && right;
    }
};

 

5.对称的二叉树

请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    bool isSymmetrical(TreeNode* pRoot)
    {
        if(!pRoot) return true;
        else return isSymTrees(pRoot->left, pRoot->right);
    }
    bool isSymTrees(TreeNode* tree1, TreeNode* tree2){
        if(!tree1 || !tree2) return !tree1 && !tree2;
        if(tree1->val == tree2->val){
            return isSymTrees(tree1->left, tree2->right)
                && isSymTrees(tree1->right, tree2->left);
        }else{
            return false;
        }
    }
};

6.输入一棵二叉树，判断该二叉树是否是平衡二叉树。

class Solution {
public:
    bool IsBalanced_Solution(TreeNode* pRoot) {
        if(pRoot == NULL) return true;
        if(abs(height(pRoot->left)-height(pRoot->right)) <= 1){
            return IsBalanced_Solution(pRoot->left) && IsBalanced_Solution(pRoot->right);
        }
        else return false;
    }
    
    int height(TreeNode* pRoot){
        if(pRoot == NULL) return 0;
        return 1 + max(height(pRoot->left), height(pRoot->right));
    }
};

7.请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    bool isSymmetrical(TreeNode* pRoot)
    {
        if(pRoot == NULL) return true;
        return isSym(pRoot->left, pRoot->right);
    }
    
    bool isSym(TreeNode* left, TreeNode* right){
        if(left && right){
            if(left->val == right->val){
                return isSym(left->left, right->right) 
                    && isSym(left->right, right->left);
            }
            else{
                return false;
            }
        }else if(left){
            return false;
        }else if(right){
            return false;
        }else return true;
        
    }

};

8.从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
        vector<vector<int> > res;
        vector<vector<int> > Print(TreeNode* pRoot) {
            dfs(pRoot, 0);
            return res;
        }
        void dfs(TreeNode* root, int depth){
            if(root == NULL) return;
            if(res.size() == depth){
                res.push_back({});
                res[depth].push_back(root->val);
            }else{
                res[depth].push_back(root->val);
            }
            dfs(root->left, depth+1);
            dfs(root->right, depth+1);
            return;
        }
    
};

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

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    vector<vector<int> > res;
    vector<vector<int> > Print(TreeNode* pRoot) {
        dfs(pRoot, 0);
        return res;
    }
    void dfs(TreeNode* pRoot, int depth){
        if(pRoot == NULL) return;
        if(res.size() == depth){
            res.push_back({});
            res[depth].push_back(pRoot->val);
        }else{
            if(depth % 2 == 0) 
                res[depth].push_back(pRoot->val);
            else
                res[depth].insert(res[depth].begin(), pRoot->val);
        }
        
        dfs(pRoot->left, depth+1);
        dfs(pRoot->right, depth+1);
        
    }
    
};