二叉树算法总结

二叉树节点的定义

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

二叉树的遍历算法

递归遍历

前序遍历

public void preOrder(TreeNode root){ 
    if (root == null)
        return;
    System.out.println(root.val);
    preOrder(root.left);
    preOrder(root.right);
}

中序遍历

public void midOrder(TreeNode root){ 
    if (root == null)
        return;
    midOrder(root.left);
    System.out.println(root.val);
    midOrder(root.right);
}

后序遍历

public void postOrder(TreeNode root){ 
    if (root == null)
        return;
    postOrder(root.left);
    postOrder(root.right);
    System.out.println(root.val);
}

非递归遍历

前序遍历

public void preOrder(TreeNode root){
    Stack<TreeNode> stack = new Stack<TreeNode>();
    while(root != null || !stack.empty()){
        while(root != null){
            System.out.print(root.val);
            stack.push(root);
            root = root.left;
        }
        if(!stack.empty()){
            root = stack.pop();
            root = root.right;
        }
    }
}

中序遍历

public void midOrder(TreeNode root){
    Stack<TreeNode> stack = new Stack<TreeNode>();
    while(root != null || !stack.empty()){
        while(root != null){
            stack.push(root);
            root = root.left;
        }
        if(!stack.empty()){
            root = stack.pop();
            System.out.println(root.val);
            root = root.right;
        }
    }
}

后序遍历

public void postOrder(TreeNode root){
    Stack<TreeNode> s = new Stack<TreeNode>();
    Stack<Integer> s2 = new Stack<Integer>();
    Integer i = new Integer(1);
    while(root != null || !s.empty()){
        while(root != null){
            s.push(root);
            s2.push(new Integer(0));
            root = root.left;
        }
        while(!s.empty() && s2.peek().equals(i)){
            s2.pop();
            System.out.println(s.pop().val);
        }
        if(!s.empty()){
            s2.pop();
            s2.push(new Integer(1));
            root =s.peek();
            root = root.right;
        }
    }
}

层次遍历

public void levelTrav(TreeNode root) {
    if(root == null)
        return;
    Queue<TreeNode> q = new ArrayDeque<TreeNode>();
    q.add(root);
    TreeNode cur;
    while (!q.isEmpty()) {
        cur = q.peek();
        System.out.print(cur.val + " ");
        if (cur.left != null)
            q.add(cur.left);
        if (cur.right != null)
            q.add(cur.right);
        q.poll();
    }
}

二叉树的深度

public int getMaxDepth(TreeNode root) {
    if (root == null)
        return 0;
    else {
        int left = getMaxDepth(root.left);
        int right = getMaxDepth(root.right);
        return 1 + Math.max(left, right);
    }
}

二叉树的宽度

public int getMaxWidth(TreeNode root) {
    if (root == null)
        return 0;
    Queue<TreeNode> queue = new ArrayDeque<TreeNode>();
    int maxWitdth = 1;                                      // 最大宽度
    queue.add(root);                                        // 入队
    while (true) {
        int len = queue.size();                             // 当前层的节点个数
        if (len == 0)
            break;
        while (len > 0) {                                   // 如果当前层，还有节点
            TreeNode t = queue.poll();
            len--;
            if (t.left != null)
                queue.add(t.left);                          // 下一层节点入队
            if (t.right != null)
                queue.add(t.right);                         // 下一层节点入队
        }
        maxWitdth = Math.max(maxWitdth, queue.size());
    }
    return maxWitdth;
}

平衡二叉树的判断

public boolean isBalanced(TreeNode root){
    if(root == null)
        return true;
    int left = getMaxDepth(root.left);
    int right = getMaxDepth(root.right);
    if(Math.abs(left-right)>1){
        return false;     
    }
    return isBalanced(root.left) && isBalanced(root.right);
}