剑指offer 树专题

树是最常用的数据结构之一。树的根结点和叶子结点是用指针链接，所以会涉及到大量的指针操作。

二叉树是最常见的树，最常见的是遍历操作：前序、中序和后序，均可以用递归实现。
一些常见的二叉树：
a. 二叉搜索树：要么是一颗空树，要么左子结点小于等于根结点，右子结点大于等于根结点；

b. 堆：一般情况下为完全二叉树，分为最小堆和最大堆，很多找最值的问题都可以用堆来解决
最小堆：根结点的值最小
最大堆：根结点的值最大

二叉排序树是为了实现动态查找而设计的数据结构，它是面向查找操作的，在二叉排序树中查找一个结点的平均时间复杂度是O(log n)；
堆是为了实现排序而设计的一种数据结构，它不是面向查找操作的，因而在堆中查找一个结点需要进行遍历，其平均时间复杂度是O(n)。

c. 红黑树（这个挺复杂的，有空慢慢研究~~）
树中的结点定义为红、黑两种颜色，并通过规则确保从根结点到叶子结点的最长路径的长度不超过最短路径的两倍。c++的STL中，set、map等都是基于红黑树实现的。

(1) 求二叉树的结点数
思路：很典型的递归

int GetNodeNum(BinaryTreeNode *pRoot)
{
    if(pRoot == NULL)
        return 0;
    return GetNodeNum(pRoot->left)+GetNodeNum(pRoot->right)+1;
}

调试一下：

#include <iostream>

using namespace std;

struct BinaryTreeNode
{
    int val;
    BinaryTreeNode *left;
    BinaryTreeNode *right;
    BinaryTreeNode(int x):val(x),left(NULL),right(NULL){}
};

int GetNodeNum(BinaryTreeNode *pRoot)
{
    if(pRoot == NULL)
        return 0;
    return GetNodeNum(pRoot->left)+GetNodeNum(pRoot->right)+1;
}
int main()
{
    BinaryTreeNode proot = BinaryTreeNode(0);
    BinaryTreeNode leftnode = BinaryTreeNode(1);
    BinaryTreeNode rightnode = BinaryTreeNode(3);
    BinaryTreeNode rrightnode = BinaryTreeNode(3);
    proot.left = &leftnode;
    proot.right = &rightnode;
    rightnode.right = &rrightnode;

    int node_num = GetNodeNum(&proot);
    cout << node)num <<endl;
    return 0;
}

(2)输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{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* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        if(pre.size() == 0 || vin.size() == 0)
            return NULL;
        return ConstructCore(pre,vin);

    }
    TreeNode* ConstructCore(vector<int> &qianxu,vector<int> &zhongxu)
    {
        int RootValue = qianxu[0];
        //初始化一个树
        TreeNode* newtree = new TreeNode(RootValue);
        newtree->left = NULL;
        newtree->right = NULL;

        vector<int> qianxuleftvec;
        vector<int> zhongxuleftvec;
        vector<int> qianxurightvec;
        vector<int> zhongxurightvec;
        int i = 0;
        int temp = 0;
        for (i =0;i<zhongxu.size();i++)
        {
            if(RootValue != zhongxu[i])
            {
                zhongxuleftvec.push_back(zhongxu[i]);
                qianxuleftvec.push_back(qianxu[i+1]);
            }
            else
            {
                temp = i;
                break;
            }
        }
        for (i =temp+1;i<zhongxu.size();i++)
        {
            zhongxurightvec.push_back(zhongxu[i]);
            qianxurightvec.push_back(qianxu[i]);
        }
        if (qianxuleftvec.size()>0)    
            newtree->left = ConstructCore(qianxuleftvec,zhongxuleftvec);
        if (qianxurightvec.size()>0)    
            newtree->right = ConstructCore(qianxurightvec,zhongxurightvec);
        return newtree;
    }
};

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

class Solution {
public:
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        if(pRoot1 == NULL || pRoot2 == NULL)
            return false;
        return isSubtree(pRoot1, pRoot2) || HasSubtree(pRoot1->left,pRoot2) || HasSubtree(pRoot1->right,pRoot2);
    }
    bool isSubtree(TreeNode* pRootA, TreeNode* pRootB)
    {
        if (pRootB == NULL) return true;
        if (pRootA == NULL) return false;
        if (pRootB->val == pRootA->val)
            return isSubtree(pRootA->left, pRootB->left) && isSubtree(pRootA->right, pRootB->right);
        else return false;
    }
};

操作给定的二叉树，将其变换为源二叉树的镜像。
输入描述:
二叉树的镜像定义：源二叉树
8
/ \
6 10
/ \ / \
5 7 9 11
镜像二叉树
8
/ \
10 6
/ \ / \
11 9 7 5

class Solution {
public:
    void Mirror(TreeNode *pRoot) {
        if (pRoot == NULL)
            return;
        TreeNode *p=pRoot->left;
        pRoot->left=pRoot->right;
        pRoot->right=p;
        Mirror(pRoot->left);
        Mirror(pRoot->right);
    }
};