二叉树的遍历（递归+迭代）

二叉树节点定义如下：

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

前序遍历

前序遍历 首先访问根节点，然后遍历左子树，最后遍历右子树。

递归实现

	//思路1：递归实现 比较简单
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        frontSearch(res,root);
        return res;
    }
    void frontSearch(vector<int>& res,TreeNode* root){
        if(root == NULL){
            return ;
        }
        else{
            res.push_back(root->val);
            frontSearch(res,root->left);
            frontSearch(res,root->right);
        }
    }

迭代实现

	vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode *> visit;
        if(root == NULL){return res;}
        while(root != NULL || visit.empty() == false){
            if(root != NULL){//在这个过程中会先保存根节点值，以及左子节点值
                res.push_back(root->val);//得到当前根节点值
                visit.push(root); //在栈中保存，当左子树扫描完弹出扫描右子树
                root = root->left;//找下一个左子树，继续上面操作
            }
            else{ //左子树完了，弹出找右子树
                root = visit.top();
                visit.pop();
                root = root->right;
            }
        }
        return res;
    }
    //思路2：迭代实现     另一种写法  逆序保存
    vector<int> preorderTraversal(TreeNode* root){
        vector<int> res;
        if(root == nullptr){return res;}
        stack<TreeNode *> visit;
        visit.push(root);
        while(!visit.empty()){
            root = visit.top();
            visit.pop();
            res.push_back(root->val);
            if(root->right != nullptr){visit.push(root->right);}
            if(root->left != nullptr){visit.push(root->left);}
        }
        return res;
    }

中序遍历

中序遍历 是先遍历左子树，然后访问根节点，然后遍历右子树。

递归实现

	//思路1：递归实现
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> value;
        middleSearch(value,root);
        return value;
    }
    void middleSearch(vector<int> &value,TreeNode* root){
        if(root == NULL){
            return;
        }
        else{
            middleSearch(value,root->left);
            value.push_back(root->val);
            middleSearch(value,root->right);
        }
    }

迭代实现

	vector<int> inorderTraversal(TreeNode* root){
        vector<int> res;
        if(root == NULL) {return res;}
        stack<TreeNode*> visit;
        while(root != NULL || !visit.empty()){
            if(root != NULL){//不为空，加入栈中并找左子树  一直向左，添加所有的左子树值
                visit.push(root);
                root = root->left;
            }
            else{
                root = visit.top();//弹出栈最顶节点  此时是最左那个节点
                visit.pop();
                res.push_back(root->val);
                root = root->right; //从右子树节点继续找看是否有左子树
            }
        }
        return res;
    }

后序遍历

后序遍历 是先遍历左子树，然后遍历右子树，最后访问树的根节点。

递归实现

	vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        backSearch(res,root);
        return res;
    }
    void backSearch(vector<int>& res,TreeNode* root){
        if(root == NULL){return;}
        backSearch(res,root->left);
        backSearch(res,root->right);
        res.push_back(root->val);
    }

迭代实现

	//思路2：迭代实现  修改前序遍历代码，将遍历左右子树的顺序对调，
    //   即可用栈保存一个根节点->右子树->左子树的遍历序列，然后反序输出即可
    vector<int> postorderTraversal(TreeNode* root){
        vector<int> res;
        if(root == NULL){return res;}
        stack<TreeNode*>visit;
        stack<int> temp;
        while(root != NULL || !visit.empty()){
            if(root != NULL){//在这个过程中会先保存根节点值，以及右子节点值
                temp.push(root->val);
                visit.push(root);
                root = root->right;
            }
            else{
                root = visit.top();
                visit.pop();
                root = root->left;
            }
        }
        while(!temp.empty()){ //将结果反序输出
            res.push_back(temp.top());
            temp.pop();
        }
        return res;
    }

二叉树层序遍历

思路：创建一个队列，先将根节点（A）入队，然后用front指针将根节点记下来，再将根节点出队，接下来看front节点（也就是刚才的根节点）有没有左孩子或右孩子，如果有，先左（B）后右（C）入队，最后输出front节点的值，只要队列还不为空，就说明还没有遍历完，就进行下一次循环，这时的队头元素（front）则为刚才入队的左孩子（B），然后front出队，再把它的左右孩子拉进来（如果有

	vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(root == NULL){return res;}
        queue<TreeNode*> visit;
        visit.push(root); //先加入根节点
        while(!visit.empty()){
            int size = visit.size(); //记录每一层节点数
            vector<int> temp;//保存临时一层节点值
            while(size > 0){
                TreeNode * front = visit.front();
                temp.push_back(front->val); //加入一层数据
                visit.pop();
                if(front->left != NULL){
                    visit.push(front->left);
                }
                if(front->right != NULL){
                    visit.push(front->right);
                }
                --size;
            }
            res.push_back(temp);
        }
        return res;
    }

二叉树最大深度

	int res = 0; 
    int maxDepth(TreeNode* root) {
        if(root == NULL){return 0;}
        findMaxDepth(root,1);
        return res;
    }
    void findMaxDepth(TreeNode* root,int depth){
        if(root == NULL){return;}
        if(root->left == NULL || root->right == NULL){//搜索左子树或右子树到最低端，更新最大深度
            res = max(res,depth);
        }
        findMaxDepth(root->left,depth+1);//递归搜索左子树，深度加1
        findMaxDepth(root->right,depth+1);
    }
    //思路2:返回左子树和右子树最大深度  + 1(根节点是1)
    int maxDepth(TreeNode* root){
        if(root == NULL){return 0;}
        return (1 + max(maxDepth(root->left), maxDepth(root->right)));
    }

对称二叉树

给定一个二叉树，检查它是否是镜像对称的。

	//思路2：递归实现  首先以根节点以及其左右子树，左子树的左子树和右子树的右子树相同，左子树的右子树和右子树
    //    的左子树相同。两个条件都要符合，所以我们第一个传根节点的左子树和右子树，先判断左右子树根结点的比较。
    //    然后分辨对左子树的左子树和右子树的右子树。左子树的右子树和右子树的左子树进行判断。
    //    只有两个条件都满足则返回的是true，一层一层递归进入，则可以得到结果。
    bool isSymmetric(TreeNode* pRoot)
    {
        // 思路：首先根结点以及其左右子树，左子树的左子树和右子树的右子树相同，
        // 左子树的右子树，和右子树的左子树相同。我们采用递归的方式
        if(pRoot == NULL){
            return true;
        }
        return comRoot(pRoot->left, pRoot->right);
    }
    bool comRoot(TreeNode* left, TreeNode* right){
        if(left == NULL){
            return right == NULL;
        }
        if(right == NULL){
            return false;//能执行到这一步，说明他的左子树肯定是不为空，此时比较右子树如果为空，那么肯定返回false
        }
        if(left->val != right->val){
            return false;
        }
        //能执行到这一步，说明其传进来的左子树和右子树不为null，且对应值相等，此时我们只需要，进行递归比较
        //传进来的左子树的左子树和传进来右子树的右子树。传进来的左子树的右子树和传进来的右子树的左子树。
        return comRoot(left->left, right->right) && comRoot(left->right, right->left);
    }

路径总和

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

	//思路：递归调用，每次sum减去当前节点值，然后分别看左右子树是否符合该路径和
    bool hasPathSum(TreeNode* root, int sum) {
        if(root == NULL){return false;}
        int count = sum - root->val;
        if(root->left == NULL && root->right == NULL){ //是叶子节点
            return count == 0; //刚好等于零，这说明符合路径和
        }
        //递归调用函数，分别判断左右子树
        return hasPathSum(root->left,count) || hasPathSum(root->right,count);
    }

从中序与后序遍历序列构造二叉树

	//思路：后续遍历最后一个是根节点，然后找到根节点后在中序遍历中左右分别为左右子树，从而递归左右子树继续上面操作
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        int len = inorder.size();
        if(len == 0 || len != postorder.size()){
            return nullptr;
        }
        TreeNode * root = nullptr;
        root = buildHelper(inorder,0,len - 1,postorder,0,len-1);
        return root;
    }
    TreeNode* buildHelper(vector<int>& inorder,int instart,int inend,vector<int>& postorder,int poststart,int postend)
    {
        if(instart > inend || poststart > postend){
            return nullptr;
        }
        TreeNode* root = new TreeNode(postorder[postend]);//后续遍历最后一个是根节点
        int index = 0; //记录root在中序遍历坐标
        for(index = instart; index <= inend; ++index){
            if(inorder[index] == postorder[postend]){//找到根节点坐标
                //中序遍历左子树起点还是instart，终点是root左边即为左子树终点
                //后续遍历左子树起点还是poststart，终点是poststart + 左子树的个数（即index-instart  
                root->left = buildHelper(inorder,instart,index-1,postorder,poststart,poststart+index-instart-1);//递归找左子树
                //中序遍历右子树起点是root右边一个即index+1，终点是inend
                //后续遍历右子树起点是poststart + 左子树的个数（即index-instart，终点是postend-1 即减去最右边根
                root->right = buildHelper(inorder,index+1,inend,postorder,poststart+index-instart,postend-1);//递归找左子树
            }
        }
        return root;
    }

从前序与中序遍历序列构造二叉树

	TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int len = preorder.size();
        if(len == 0 || len != inorder.size()){
            return nullptr;
        }
        TreeNode* root = nullptr;
        root = buildHelper(preorder,0,len - 1,inorder,0,len - 1);
        return root;
    }
    TreeNode* buildHelper(vector<int>& preorder,int prestart,int preend,vector<int>& inorder,int instart,int inend)
    {
        if(prestart > preend || instart > inend){
            return nullptr;
        }
        TreeNode* root = new TreeNode(preorder[prestart]);//前序遍历第一个是根节点
        int index = 0; //记录root在中序遍历坐标
        for(index = instart; index <= inend; ++index){
            if(inorder[index] == preorder[prestart]){//找到根节点坐标
                //前序遍历的左子树起点是prestart+1，终点是prestart+左子树个数(即index-instart) +1后-1，加1是第一个根节点
                //中序遍历的左子树起点是instart，终点是index-1
                root->left = buildHelper(preorder,prestart+1,prestart+index-instart,inorder,instart,index-1);//递归找左子树
                //前序遍历的右子树起点是prestart+左子树个数(即index-instart)+1，终点是preend
                //中序遍历的右子树起点是index+1，终点是inend
                root->right = buildHelper(preorder,prestart+index-instart+1,preend,inorder,index+1,inend);//递归找you子树
            }
        }
        return root;
    }

二叉树最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

	//思路：对于二叉树查找题大都从左右子树递归解决，需首先确定临界条件为空或是root=q、root=p，则改题简化为查找以
    //root为根树上是否有p或q节点，如果有返回p或q，否则返回null，则对左右子树递归查找是否有p、q，分4种情况：
    //1、左子树找到，右子树找不到，直接返回左子树查找结果；
    //2、左子树找不到，右子树找到，直接返回右子树查找结果；
    //3、左右子树均找到，说明p、q分居root两侧，直接返回root   在root的两侧处
    //4、左右均找不到（虽然p、q节点必存在，但是递归会找子树不一定满足全局条件）返回null
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == nullptr || root == p || root ==q){//找到了，或为空返回终止递归
            return root;
        }
        TreeNode* left = lowestCommonAncestor(root->left,p,q);//递归找左子树
        TreeNode* right = lowestCommonAncestor(root->right,p,q);
        if(left == nullptr && right == nullptr){return nullptr;}
        else if(left == nullptr && right != nullptr){return right;}//会根据递归一直返回该节点
        else if(left != nullptr && right == nullptr){return left;}
        else {return root;}//一直有左右子树节点，说明分居root两侧，返回root
    }

二叉树序列化和反序列化

序列化

	// Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        if(root == nullptr){return "#";}
        stringstream ss;
        string cur = "";
        ss<<root->val<<","<<serialize(root->left)<<","<<serialize(root->right);
        ss>>cur;
        return cur;
    }

反序列化

	// Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        //string拆分数组
        queue<string> temp;
        int index = data.find(",");
        while(index != data.npos){
            temp.push(data.substr(0,index));
            //cout<<data.substr(0,index)<<"  ";
            data = data.substr(index + 1,data.length());
            index = data.find(",");
        }
        temp.push(data);
        //cout<<data<<endl;
        TreeNode* root = deserializeHelper(temp);
        return root;
    }
    TreeNode* deserializeHelper(queue<string>& temp){
        //if(temp.size() <= 0){return nullptr;}
        string top = temp.front();
        temp.pop();
        if(top == "#"){return nullptr;}
        else{
            TreeNode* root = new TreeNode(atoi(top.c_str()));
            root->left = deserializeHelper(temp);
            root->right = deserializeHelper(temp);
            return root;
        }
    }