二叉树的创建

1. 带有空节点的前序 -> 创建二叉树

不能用普通的前序遍历创建二叉树，得到的二叉树不唯一。因此，使用带空节点的前序遍历来创建二叉树。根据带空节点的前序遍历，可以简单明确的得到根节点(下标为0的结点)。

• 1.1 步骤

1. 通过前序遍历的第一个值创建根节点
2. 将除了根节点之外的其他值存入左遍历
3. 通过左遍历创建左子树，并获得左遍历使用的节点个数及左子树的根
4. 将除了根节点以及左子树使用的节点之外的其他值存入右遍历
5. 通过右遍历创建右子树，并获得右遍历使用的节点个数及右子树的根
6. 把左右子树与根联系起来
7. 返回根节点以及使用节点个数

• 1.2 代码

/**
 * 利用带空节点的前序创建二叉树
 * Author:qqy
 */
public class Tree {
    private static class Node {
        char value;
        //左子树
        Node left;
        //右子树
        Node right;

        Node(char v) {
            this.value = v;
        }
    }

    /**
     * @param preOrder 带空节点的前序遍历
     * @return 创建好的二叉树的根结点
     */
    public  CreateTreeReturnValue createTree(char[] preOrder){
        //终止条件
        //若所给遍历的个数为0，则认为创建空树
        if(preOrder==null){
            return new CreateTreeReturnValue(null,0);
        }
        //如果根结点为"#"，返回null，1
        if(preOrder[0]=='#'){
            return  new CreateTreeReturnValue(null,1);
        }
        
        //递推过程
        //1.创建根节点
        Node root=new Node(preOrder[0]);
        //2.左子树
        char[] leftPreOrder=new char[preOrder.length-1];
        //将指定数组的指定范围复制到新数组中，包括from，排除to
        //左遍历：除根节点以外的节点
        leftPreOrder=Arrays.copyOfRange(preOrder,1,preOrder.length);
        CreateTreeReturnValue returnLeft=createTree(leftPreOrder);
        //3.右子树
        //右子树的长度=length-根的长度-左子树的长度
        char[] rightPreOrder=new char[preOrder.length-1- returnLeft.used];
        //右遍历：右子树的节点
        rightPreOrder=Arrays.copyOfRange(preOrder,1+returnLeft.used,preOrder.length);
        CreateTreeReturnValue returnRight=createTree(rightPreOrder);
        //绑定左右子树和根
        root.left=returnLeft.returnRoot;
        root.right=returnRight.returnRoot;

        //创建好的树的根结点是root
        //使用的个数是根使用的(1)+左子树使用(returnLeft.used)+右子树使用的(returnRight.used)
        return new CreateTreeReturnValue(root,1+returnLeft.used+returnRight.used);
    }

    /**
     * 为了实现一个函数返回两个值的效果，把两个不同的返回值打包到一个类里
     */
    class CreateTreeReturnValue{
        //创建好的二叉树的根节点
        public Node returnRoot;
        //左子树使用的个数
        public int used;

         CreateTreeReturnValue(Node returnRoot,int used){
            this.returnRoot=returnRoot;
            this.used=used;
        }
    }
}

• 1.3 画图理解

2.  前序+中序 -> 创建二叉树

由于前序和后序更便于找根，中序便于切分左右子树。因此，前序+中序 / 后序+中序都可以创建二叉树，而前序+后序不行。

• 2.1 步骤

1. 在前序中找到根的值preOrder[0]
2. 在中序中找到根的值所在的下标index -> 左子树的个数=index
3. 切出左子树的前序+中序 -> 前序：preOrder[1]~preOrder[index]  中序：inOrder[0]~inOrder[index-1]
4. 切出右子树的前序+中序 -> 前序：preOrder[1+index]~preOrder[length-1]  中序：inOrder[index+1]~inOrder[length-1] 

• 2.2 代码

import java.util.Arrays;

/**
 * 前序+中序创建二叉树
 * Author:qqy
 */
public class PreInCreateTree {
    public class Node{
        int value;
        Node left;
        Node right;
        Node(int value){
            this.value=value;
        }
    }

    public int find(int[] array,int v){
        for(int i=0;i<array.length;i++){
            if(array[i]==v){
                return i;
            }
        }
        return -1;
    }

    public Node preInCreateTree(int[] preOrder,int[] inOrder){
        //终止条件
        //前序和中序的长度适中相同，因此，其中一个为空，都为空。
        //为空，视为空树
        if(preOrder.length==0){
            return null;
        }

        //根据前序找到并创建根结点
        Node root=new Node(preOrder[0]);
        //在inOrder中找到root的下标
        int index=find(inOrder,root.value);

        //切出左子树的前序+中序
        //由于to排他，因此和步骤中的不同，需要+1
        int[] leftPre=Arrays.copyOfRange(preOrder,1,index+1);
        int[] leftIn=Arrays.copyOfRange(inOrder,0,index);
        root.left=preInCreateTree(leftPre,leftIn);

        //切出右子树
        int[] rightPre=Arrays.copyOfRange(preOrder,1+index,preOrder.length);
        int[] rightIn=Arrays.copyOfRange(inOrder,index+1,inOrder.length);
        root.right=preInCreateTree(rightPre,rightIn);

        return root;
    }
}

3.  后序+中序 -> 创建二叉树

• 3.1 步骤

1. 在后序中找到根的值preOrder[length-1]
2. 在中序中找到根的值所在的下标index -> 左子树的个数=index
3. 切出左子树的后序+中序 -> 后序：preOrder[0]~preOrder[index-1]  中序：inOrder[0]~inOrder[index-1]
4. 切出右子树的后序+中序 -> 后序：preOrder[index]~preOrder[length-2]  中序：inOrder[index+1]~inOrder[length-1] 

• 3.2 代码

/**
 * 后序+中序创建二叉树
 * Author:qqy
 */
public class PostInCreateTree {
    private class Node {
        int value;
        //左子树
        Node left;
        //右子树
        Node right;

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

    public Node buildTree(int[] inOrder, int[] postOrder) {
        //终止条件
        if (inOrder.length == 0) {
            return null;
        }

        //取得根结点
        Node root = new Node(postOrder[postOrder.length - 1]);
        //查找根结点在中序的位置
        int index = find(inOrder, root.value);

        //切分左子树
        int[] leftin = Arrays.copyOfRange(inOrder, 0, index);
        int[] leftpost = Arrays.copyOfRange(postOrder, 0, index);
        root.left = buildTree(leftin, leftpost);

        //切分右子树
        int[] rightin = Arrays.copyOfRange(inOrder, index + 1, inOrder.length);
        int[] rightpost = Arrays.copyOfRange(postOrder, index, postOrder.length - 1);
        root.right = buildTree(rightin, rightpost);

        return root;
    }

    public int find(int[] array, int v) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == v) {
                return i;
            }
        }
        return -1;
    }
}