二叉树

1.递归二叉树：递归方式实现二叉树的先序，中序，后序遍历

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
class TreeToSequence {
public:
    vector<vector<int> > convert(TreeNode* root) 
    {
        vector<vector<int>> res;
        vector<int> temp;
        PreOrderTraverse(root,temp);
        res.push_back(temp);
        temp.clear();
        InOrderTraverse(root,temp);
        res.push_back(temp);
        temp.clear();
        PostOrderTraverse(root,temp);
        res.push_back(temp);
        return res;

    }
    void PreOrderTraverse(TreeNode *root,vector<int> &arr){
        if(!root)
            return ;
        arr.push_back(*root.val);
        PreOrderTraverse(*root.left,arr);
        PreOrdertraverse(*root.right.arr);
    }
    void InOrderTraverse(TreeNode* root,vector<int> &arr)
    {
        if(!root)
            return;
        InOrderTraverse((*root).left,arr);
        arr.push_back((*root).val);
        InOrderTraverse((*root).right,arr);
    }
    void PostOrderTraverse(TreeNode* root,vector<int> &arr)
    {
        if(!root)
            return;
        PostOrderTraverse((*root).left,arr);
        PostOrderTraverse((*root).right,arr);
        arr.push_back((*root).val);
    }
};

2. 先序遍历非递归实现：

思路：首先申请一个栈，将头节点压入栈中，每次从栈中弹出顶元素，打印，如果右孩子不为空则压入，左孩子不为空压入。

import java.util.ArrayList;
import java.util.Stack;

public class binaryPreTraversal {
     public ArrayList<Integer> preorderTraversal(TreeNode root) {
         ArrayList<Integer> arr = new ArrayList<>();
         if(root==null)
             return arr;
         Stack<TreeNode> stack = new Stack<>();
         stack.push(root);
         while(!stack.isEmpty()) {
             TreeNode nod = stack.pop();
             arr.add(nod.val);
             if(nod.right!=null)
                 stack.push(nod.right);
             if(nod.left!=null)
                 stack.push(nod.left);
         }
         return arr;
     }

}

2. 中序遍历非递归实现：

思路：申请一个栈
对左孩子结点一直入栈，
右孩子结点为空，则范围，然后访问其右孩子结点

void InOrderTraverse(TreeNode* root,vector<int> &arr){
    if(!root)
        return ;
    stack<TreeNode *>temp;
    TreeNode *p =root;
    while(!temp.empty()||p){
        while(p){
            temp.push(p);
            p=*p.left;
        }
        p=temp.top();
        temp.pop();
        arr.push_back(*p.val);
        p=*p.right;
    }
}；      

3.后序遍历非递归实现

思路：
1.申请一个栈
2.对左孩子一直入栈
3.左孩子为空时候，进行判断
3.1 当右孩子为空 访问当前结点（出栈），新建一个flag结点存放当前结点 设置下一轮循环结点为null
3.2 当右孩子不为空 并且右孩子结点不是对应的flag 结点（可以理解为上一访问过的结点） 右节点进栈，下一轮循环结点为 该右节点的左孩子节点。

import java.util.ArrayList;
import java.util.Stack;

public class binaryPosTraversal {
    public ArrayList<Integer> postorderTraversal(TreeNode root){
        Stack<TreeNode> stack = new Stack<>();
        ArrayList<Integer> arr = new ArrayList<>();
        if(root==null)
            return null;
        TreeNode r=null;

        while(!stack.isEmpty() || root!=null) { 
            while(root!=null) {
                stack.push(root);
                root= root.left;
            }
            TreeNode nod = stack.peek();
            root = nod.right;
            if(root!=null && root!=r) {
                stack.push(root);
                root=root.left;
            }
            else {
                //访问 置空 并记录为上一个结点
                root = stack.pop();
                arr.add(root.val);
                r = root;
                root =null;     
            }
        }
        return arr;
    }
}

平衡二叉树：AVL树
1.空树为平衡二叉树
2.树不为空，所有子树都满足各自的左子树和右子树高度差不超过1

平衡二叉树判断：给定一个根节点root,判断这棵树是否为平衡二叉树。

class CheckBalance {
public:
    bool check(TreeNode* root) 
    {
        int Depth=0;
        return IsBalance(root,Depth);
    }
    bool IsBalance(TreeNode *root,int &Depth){
        if(root==Null){
            depth=0;
            return true;
        }
        int left=0,right=0,differ=0;
        if(IsBalance(*root.left,left)&&IsBalance(*root.right,right){
            differ =left-right;
            depth = left>right?left+1:right+1;
            if(differ<=1&&differ>=-1)
                return true;
            }
            return false;
        }
};

搜索二叉树：（二叉查找树或二叉排序树）
每颗树的头节点值比各左子树的所有节点值要大，比各自右子树的所有节点值要小。
中序遍历：从小到大排列
红黑树、平衡二叉搜索树等。

完全二叉树判断：给定一个二叉树根节点root,判断是否为完全二叉树。
思路：层次遍历，有右孩子，没有左孩子 false.如果当前节点不是左右孩子都有，则之后节点都为叶节点。

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
class CheckCompletion {
public:
    bool chk(TreeNode* root) 
    {
        if(!root)
            return true;
        queue<TreeNode *>que;
        que.push(root);
        TreeNode *temp = Null;
        while(!que.empty()){
            temp =que.front();
            que.pop();
            //有右节点没有左节点
            if(!*temp.left && *temp.right)
                return false;
            if((*temp).left)
                que.push((*temp).left);
            if((*temp).right)
                que.push((*temp).right);
            if(!*temp.left||!*temp.right)
                break;
        }
        while(!que.empty()){
            temp = que.front();
            que.pop();
            //该层其他节点为叶子节点才为true.
            if((*temp).left||(*temp).right)
                return false;
        }
        return true;
    }
};