【Tree】判断平衡二叉树AVL

/***********************************
https://leetcode.com/problems/balanced-binary-tree/
@date 2015.5.8
@description
给定一个二叉树，判断是否是平衡二叉树
@tags tree, DFS

平衡二叉树满足的条件：
1.左右子树的高度差不大于1
2.左右子树均是平衡二叉树

本次解决方案提供了两种方法：
Solution1.
递归先分别算出左右子树的高度，再做差与1比较，如果≤1，则再判断左右子树是否为AVL

Solution2.
计算并返回左右子树的高度，同时可以判断左右子树是否为AVL树，
这样就不需要在判断左右字数高度差不大于1之后再回去判断左右子树是否为AVL树

测试函数中增加了搜索二叉树的创建 和 递归先序遍历二叉树


************************************/


#include <iostream>
#include <stdlib.h>

using namespace std;

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


class Solution{
public:
    bool isBalanced(TreeNode *root){
        // 递归
        if (!root) return true; // 空树也是AVL
        int depthLeft = maxDepth(root->left);
        int depthRight = maxDepth(root->right); // 算左右子树的最大深度，即为树的高度
        if (abs(depthLeft - depthRight) <= 1) // 左右子树的高度差不超过1，条件之一
            return isBalanced(root->left) && isBalanced(root->right); // 左右子树都是AVL，条件二
        else
            return false;
    }

    int maxDepth(TreeNode *root){
        if (!root) return 0;
        return 1 + max(maxDepth(root->left), maxDepth(root->right));
    }

};


class Solution2{
public:
    bool isBalanced(TreeNode *root){
        return dfsDepth(root) != -1;
    }

    int dfsDepth(TreeNode *root){
        if (!root) return 0;
        int leftDepth = dfsDepth(root->left);
        if (leftDepth == -1) return -1;
        int rightDepth = dfsDepth(root->right);
        if (rightDepth == -1) return -1;

        if (abs(leftDepth - rightDepth) > 1)
            return -1;
        return max(leftDepth, rightDepth) + 1;
    }
};

TreeNode *insert(TreeNode *root, int data){
    TreeNode *ptr = root;
    TreeNode *tempNode; // 存储的是插入节点的父节点
    TreeNode *newNode = new TreeNode(data);

    if (ptr == NULL)
        return newNode;
    else{
        while (ptr != NULL){
            tempNode = ptr;
            if (ptr->val >= data){
                ptr = ptr->left;
            }else{
                ptr = ptr->right;
            }
        }
        if (tempNode->val >= data){
            tempNode->left = newNode;
        }else{
            tempNode->right = newNode;
        }
    }
    return root;
}

// 递归先序遍历二叉树
void travPre(TreeNode *root){
    if (!root) return;
    cout << root->val << " ";
    travPre(root->left);
    travPre(root->right);
}


int main(){
    TreeNode *root = NULL;
    int temp = 0;
    cin >> temp;
    while (temp != 0){ // 以0结尾（输入0终止）
        root = insert(root, temp);
        cin >> temp;
    } // 创建一棵二叉树

    // 递归先序遍历
    travPre(root);

    cout << endl;
    Solution2 a;
    cout << a.isBalanced(root);
}