二叉树的基本算法

二叉树

结构描述

Class Node {
	V value;
	Node left;
	Node right;
}

先、中、后序遍历

先序：任何子树的处理顺序都是，先头节点、再左子树、然后右子树

中序：任何子树的处理顺序都是，先左子树、再头节点、然后右子树

后序：任何子树的处理顺序都是，先左子树、再右子树、然后头节点

递归实现

递归序，每个结点都会到达3次,第一次到达一个节点就打印就是先序、第二次打印即中序、第三次即后序。

求X祖先结点：

先序：[…A…]X[]
后续：[]X[…B…]
A区间 ∩ B区间 得到的就是X的父所有祖先节点

/**
 * 递归遍历二叉树
 */
public class RecursiveTraversalBT {

    //二叉树结点
    public static class Node{
        public int value;
        public Node left;
        public Node right;
        public Node(int value) {
            this.value = value;
        }
    }

    //先序遍历
    public static void pre(Node head){
        //base case
        if(head == null){
            return;
        }
        System.out.println(head.value);
        pre(head.left);
        pre(head.right);
    }
    //中序遍历
    public static void in(Node head){
        //base case
        if (head == null){
            return;
        }
        in(head.left);
        System.out.println(head.value);
        in(head.right);
    }
    //后序遍历
    public static void pos(Node head){
        //base case
        if (head == null){
            return;
        }
        pos(head.left);
        pos(head.right);
        System.out.println(head.value);
    }

    public static void main(String[] args) {
        Node head = new Node(1);
        head.left = new Node(2);
        head.right = new Node(3);
        head.left.left = new Node(4);
        head.left.right = new Node(5);
        head.right.left = new Node(6);
        head.right.right = new Node(7);

        pre(head);
        System.out.println("========");
        in(head);
        System.out.println("========");
        pos(head);
        System.out.println("========");

    }
}

非递归实现

1）任何递归函数都可以改成非递归

2）自己设计压栈的来实现

package com.lzf2.class09;

import java.util.Stack;

/**
 * 非递归遍历二叉树
 */
public class UnRecursiveTraversalBT {
    //二叉树结点
    public static class Node{
        public int value;
        public Node left;
        public Node right;
        public Node(int value) {
            this.value = value;
        }
    }

    //先序
    public static void pre(Node head){
        if (head == null){
            return;
        }
        Stack<Node> stack = new Stack<>();
        stack.push(head);
        while (!stack.isEmpty()){
            Node node = stack.pop();
            System.out.println(node.value);
            if (node.right != null){
                stack.push(node.right);
            }
            if (node.left != null){
                stack.push(node.left);
            }
        }
    }
    //中序
    // 1.当前节点cur,cur为头的树，整条左边界全部进栈，直到为空。
    // 2.从栈中弹出节点打印打印，这个节点的右节点为cur,转第一步
    // 3.栈为空停
    public static void in(Node head){
        if (head == null){
            return;
        }
        Node cur = head;
        Stack<Node> stack = new Stack<>();

        while (cur != null || !stack.isEmpty()){
            if (cur != null){//左边一整条入栈
                stack.push(cur);
                cur = cur.left;
            }else {
                cur = stack.pop();
                System.out.println(cur.value);
                cur = cur.right;
            }
        }


    }
    //后序  先序：头左右 -> 头右左（先压左在压右） -> 从栈中出来不输出，放到另外一个栈。最后弹出 左右头
    public static void pos(Node head){
        if (head == null){
            return;
        }
        Stack<Node> s1 = new Stack<>();
        Stack<Node> s2 = new Stack<>();
        s1.push(head);
        while (!s1.isEmpty()){
            Node node = s1.pop();
            s2.push(node);
            if (node.left != null){
                s1.push(node.left);
            }
            if (node.right != null){
                s1.push(node.right);
            }
        }
        while (!s2.isEmpty()){
            Node node = s2.pop();
            System.out.println(node.value);
        }
    }


    public static void main(String[] args) {
        Node head = new Node(1);
        head.left = new Node(2);
        head.right = new Node(3);
        head.left.left = new Node(4);
        head.left.right = new Node(5);
        head.right.left = new Node(6);
        head.right.right = new Node(7);

        pre(head);
        System.out.println("========");
        in(head);
        System.out.println("========");
        pos(head);
        System.out.println("========");
    }
}

层次遍历

1）其实就是宽度优先遍历，用队列

2）可以通过设置flag变量的方式，来发现某一层的结束（看题目）

package com.lzf2.class09;

import java.util.LinkedList;
import java.util.Queue;

//树的层次遍历
public class LevelTraversalBT {

    private static class Node{
        int value;
        Node left;
        Node right;

        public Node(int value) {
            this.value = value;
        }
    }

    public static void level(Node head){
        if (head == null){
            return;
        }
        Queue<Node> queue = new LinkedList();
        queue.add(head);
        while (!queue.isEmpty()){
            Node cur = queue.poll();
            System.out.println(cur.value);
            if (cur.left != null){
                queue.add(cur.left);
            }
            if (cur.right != null){
                queue.add(cur.right);
            }
        }
    }
    public static void main(String[] args) {
        Node head = new Node(1);
        head.left = new Node(2);
        head.right = new Node(3);
        head.left.left = new Node(4);
        head.left.right = new Node(5);
        head.right.left = new Node(6);
        head.right.right = new Node(7);

        level(head);
        System.out.println("========");
    }
}

树的序列化和反序列化

1）先序方式序列化和反序列化

2）按层方式序列化和反序列化

二叉树可以通过先序、后序、和层次遍历序列序列化和反序列化。但是不能通过中序序列序列号和反序列化，因为不同的树，可能得到同样的中序序列。

package com.lzf2.class09;


import java.util.LinkedList;
import java.util.Queue;

//树的序列化和反序列化
//不要忽略掉null
public class SerializeAndReconstructTree {
    //树的结点
    public static class Node{
        int value;
        Node left;
        Node right;

        public Node(int value) {
            this.value = value;
        }
    }

    //1.1 序列化（先序）
    public static Queue<String> preSerial(Node head){
        Queue<String> ans = new LinkedList<>();
        pres(head,ans);
        return ans;
    }
    private static void pres(Node head,Queue<String> ans){
        //base case
        if(head == null){
            ans.add(null);
        }else {
            ans.add(String.valueOf(head.value));
            pres(head.left,ans);
            pres(head.right,ans);
        }
    }
    //1.2 反序列化（先序）
    public static Node buildByPreQueue(Queue<String> prelist){
        if (prelist == null || prelist.size() == 0){
            return null;
        }
        return preb(prelist);
    }
    private static Node preb(Queue<String> prelist){
        String value = prelist.poll();
        //base case
        if (value == null){
            return null;
        }
        //造出结点
        Node head = new Node(Integer.valueOf(value));
        //先消费左边
        head.left = preb(prelist);
        //再右边
        head.right = preb(prelist);
        return head;
    }
    //2.根据后序的 序列化 和 反序列化 和先序差不多，根据先序可以很容易就改出来

    //3.1 序列化（按层方式）
    public static Queue<String> levelSerial(Node head){
        Queue<String> ans = new LinkedList<>();
        if (head == null){
            ans.add(null);
            return ans;
        }
        Queue<Node> queue = new LinkedList<>();
        ans.add(String.valueOf(head.value));
        queue.add(head);
        while (!queue.isEmpty()){
            Node node = queue.poll();
            if (node.left != null){
                //加到队列，并且序列化
                queue.add(node.left);
                ans.add(String.valueOf(node.left.value));
            }else {
                //只序列化
                ans.add(null);
            }
            if (node.right != null){
                //加到队列，并且序列化
                queue.add(node.right);
                ans.add(String.valueOf(node.right.value));
            }else {
                //只序列化
                ans.add(null);
            }
        }
        return ans;
    }
    //3.2 反序列化（按层方式）
    public static Node buildByLevelQueue(Queue<String> levelList){
        if (levelList == null || levelList.size() == 0){
            return null;
        }
        Node head = generateNode(levelList.poll());
        Queue<Node> queue = new LinkedList<>();
        if (head != null){
            queue.add(head);
        }

        while (!queue.isEmpty()){
            Node node = queue.poll();
            node.left = generateNode(levelList.poll());
            node.right = generateNode(levelList.poll());
            if (node.left != null){
                queue.add(node.left);
            }
            if (node.right != null){
                queue.add(node.right);
            }
        }

        return head;
    }
    public static Node generateNode(String val){
        if (val == null){
            return null;
        }
        return new Node(Integer.valueOf(val));
    }




    // for test
    public static Node generateRandomBST(int maxLevel, int maxValue) {
        return generate(1, maxLevel, maxValue);
    }
    // for test
    public static Node generate(int level, int maxLevel, int maxValue) {
        if (level > maxLevel || Math.random() < 0.5) {
            return null;
        }
        Node head = new Node((int) (Math.random() * maxValue));
        head.left = generate(level + 1, maxLevel, maxValue);
        head.right = generate(level + 1, maxLevel, maxValue);
        return head;
    }
    // for test
    public static boolean isSameValueStructure(Node head1, Node head2) {
        if (head1 == null && head2 != null) {
            return false;
        }
        if (head1 != null && head2 == null) {
            return false;
        }
        if (head1 == null && head2 == null) {
            return true;
        }
        if (head1.value != head2.value) {
            return false;
        }
        return isSameValueStructure(head1.left, head2.left) && isSameValueStructure(head1.right, head2.right);
    }
    // for test
    public static void printTree(Node head) {
        System.out.println("Binary Tree:");
        printInOrder(head, 0, "H", 17);
        System.out.println();
    }
    public static void printInOrder(Node head, int height, String to, int len) {
        if (head == null) {
            return;
        }
        printInOrder(head.right, height + 1, "v", len);
        String val = to + head.value + to;
        int lenM = val.length();
        int lenL = (len - lenM) / 2;
        int lenR = len - lenM - lenL;
        val = getSpace(lenL) + val + getSpace(lenR);
        System.out.println(getSpace(height * len) + val);
        printInOrder(head.left, height + 1, "^", len);
    }
    public static String getSpace(int num) {
        String space = " ";
        StringBuffer buf = new StringBuffer("");
        for (int i = 0; i < num; i++) {
            buf.append(space);
        }
        return buf.toString();
    }

    public static void main(String[] args) {
        int maxLevel = 5;
        int maxValue = 100;
        int testTimes = 1000000;
        System.out.println("test begin");
        for (int i = 0; i < testTimes; i++) {
            Node head = generateRandomBST(maxLevel, maxValue);
            Queue<String> pre = preSerial(head);
            Queue<String> level = levelSerial(head);
            Node preBuild = buildByPreQueue(pre);
            Node levelBuild = buildByLevelQueue(level);
            if (!isSameValueStructure(preBuild, levelBuild) ) {
                System.out.println("Oops!");
            }
        }
        System.out.println("test finish!");
    }
}