二叉树的构造及遍历

　　二叉树是一种特殊的树形结构，每个节点最多有两个子节点，两个节点有左右之分，次序不能颠倒。一般使用递归来定义二叉树，因此与二叉树相关的问题都可以通过递归来解决，二叉树节点的定义如下： 

class Node{
    public int value=-1;
    public Node leftNode;
    public Node rightNode;
    public Node(int val){
        value=val;
    }
    public Node(){
        this(null); 
    }
}

 接下来介绍根据已知的二叉树结构，构造二叉树的方法。首先给出两个二叉树的结构，如下图所示：

1）根据已有的二叉树结构，生成节点数组，依据节点数组构造二叉树时。约定输入的正数表示其节点编号，负数表示节点不存在。从根节点开始，构造其左子树，如果此树上还有左子树，继续操作，直至没有左子树，然后构造右子树。以A为例说明生成节点数组的过程，设节点数组为nodeArr。首先访问根节点1(nodeArr=[1])，有左子树且根节点为2(nodeArr=[1,2])，以2为根节点继续访问，仍然有左子树且根节点为4(nodeArr=[1,2,4])，继续访问，没有左子树(nodeArr=[1,2,4,-1]),也没有右子树(nodeArr=[1,2,4,-1,-1])，返回到上层，访问2的右子树，且右子树根节点为5(nodeArr=[1,2,4,-1,-1,5]),发现5没有左节点和右节点(nodeArr=[1,2,4,-1,-1,5,-1,-1])，依此类推，最终A的节点数组为nodeArr=[1,2,4,-1,-1,5,-1,-1,3,-1,6,-1,-1]。同理，设B的节点数组为nodeArr2，有nodeArr2=[1,2,4,-1,-1,5,9,-1,-1,-1,3,6,7,-1,8,-1,-1,-1,-1]。

2）根据节点数组，生成二叉树，代码如下：

public class traversal {
    static int step=0;
    public static void main(String[] args){
        int[] nodeArray=new int[]{1,2,4,-1,-1,5,-1,-1,3,-1,6,-1,-1};
        int[] nodeArray2=new int[]{1,2,4,-1,-1,5,9,-1,-1,-1,3,6,7,-1,8,-1,-1,-1,-1};
        Node root=new Node();
        root=createBinaryTree(root,nodeArray2);
        System.out.println("end");
    }
    public static Node createBinaryTree(Node root,int[] nodeArray ){
        int val=-1;
        try {
            val = nodeArray[step];
            step++;
        }
        catch (ArrayIndexOutOfBoundsException ex){
            System.out.println("(ArrayIndexOutOfBounds,check the nodeArray");
        }
        if(val<0){
            System.out.println("leaf node");
            root=null;
            return root;
        }
        root=new Node(val);///指向新对象
        //step++;
        root.leftNode=createBinaryTree(root.leftNode,nodeArray);
        root.rightNode=createBinaryTree(root.rightNode,nodeArray);
        return root;
    }
}
class Node{
    public int value=-1;
    public Node leftNode;
    public Node rightNode;
    public Node(int val){
        value=val;
    }
    public Node(){
    }
}

3）结果如下所示：

   

动画演示:http://student.zjzk.cn/course_ware/data_structure/web/flashhtml/erchashujianli.htm

4）事实上，上述构造二叉树的过程是使用了二叉树的先序遍历完成的。在二叉树已经构造完成的基础上，分别完成先序遍历、中序遍历、后序遍历和层次遍历。

先序遍历：先访问根节点，再访问左节点，后访问右节点。如果左节点上还有左子树，继续访问其左节点，然后再访问右节点。

中序遍历：左节点、根节点、右节点。

后序遍历：左节点、右节点、根节点。

层次遍历：首先访问第0层，当i层所有节点访问完之后，再从左向右访问i+1层的各个节点。

使用递归的方法完成先序遍历、中序遍历、后序遍历，使用队列的方法完成层次遍历。代码如下： 

import java.util.LinkedList;
import java.util.Queue;
public class traversal {
    static int step=0;
    public static void main(String[] args){
        int[] nodeArray=new int[]{1,2,4,-1,-1,5,-1,-1,3,-1,6,-1,-1};
        int[] nodeArray2=new int[]{1,2,4,-1,-1,5,9,-1,-1,-1,3,6,7,-1,8,-1,-1,-1,-1};
        Node root=new Node();
        root=createBinaryTree(root,nodeArray);
        System.out.println("tree A:");
        System.out.println("先序遍历:");
        nlr(root);
        System.out.println("
" + "中序遍历：");
        lnr(root);
        System.out.println("
" + "后序遍历：");
        lrn(root);
        System.out.println("
" + "层次遍历：");
        levelTraversal(root);
        Node root2=new Node();
        step=0;
        root2=createBinaryTree(root2,nodeArray2);
        System.out.println("
"+"tree B:");
        System.out.println("先序遍历:");
        nlr(root2);
        System.out.println("
" + "中序遍历：");
        lnr(root2);
        System.out.println("
" + "后序遍历：");
        lrn(root2);
        System.out.println("
" + "层次遍历：");
        levelTraversal(root2);
    }
    public static Node createBinaryTree(Node root,int[] nodeArray ){
        int val=-1;
        try {
            val = nodeArray[step];
            step++;
        }
        catch (ArrayIndexOutOfBoundsException ex){
            System.out.println("(ArrayIndexOutOfBounds,check the nodeArray");
        }
        if(val<0){
            //System.out.println("leaf node");
            root=null;
            return root;
        }
        root=new Node(val);///指向新对象
        //step++;
        root.leftNode=createBinaryTree(root.leftNode,nodeArray);
        root.rightNode=createBinaryTree(root.rightNode,nodeArray);
        return root;
    }
    public static void nlr(Node head){
        if(head==null){
            return;
        }
        System.out.print(head.value+"	");
        nlr(head.leftNode);
        nlr(head.rightNode);
    }
    public static void lnr(Node head){
        if(head==null){
            return;
        }
        lnr(head.leftNode);
        System.out.print(head.value + "	");
        lnr(head.rightNode);
    }
    public static void lrn(Node head){
        if(head==null){
            return;
        }
        lrn(head.leftNode);
        lrn(head.rightNode);
        System.out.print(head.value + "	");
    }
    public static void levelTraversal(Node head){
        Queue<Node> nodeQueue=new LinkedList<>();
        nodeQueue.offer(head);
        while(!nodeQueue.isEmpty()){
            Node node=nodeQueue.poll();
            System.out.print(node.value+"	");
            if (node.leftNode!=null){
                nodeQueue.offer(node.leftNode);
            }
            if(node.rightNode!=null){
                nodeQueue.offer(node.rightNode);
            }
        }
        return;
    }
}
class Node{
    public int value=-1;
    public Node leftNode;
    public Node rightNode;
    public Node(int val){
        value=val;
    }
    public Node(){
    }
}

 运行结果图：

 三种遍历的非递归实现： 

//非递归形式的先序遍历
    public static void nlr2(Node head){
        if (head!=null){
            return;
        }
        Stack<Node> stack=new Stack<>();
        stack.push(head);
        while (!stack.empty()){
            Node temp=stack.peek();
            System.out.println(temp.value+"	");
            stack.pop();
            if(temp.rightNode!=null){
                stack.push(temp.rightNode);
            }
            if(temp.leftNode!=null){
                stack.push(temp.leftNode);
            }
        }

    }

void lnr2(Node *root)//非递归中序遍历
{
    stack<Node *> stk;
    Node *p = root;
    while (p != NULL || !stk.empty())
    {
        if (p != NULL)
            stk.push(p), p = p->left;
        else
        {
            p = stk.top(); stk.pop();
            printf("%d ", p->val);
            p = p->right;
        }
    }
}
 //非递归形式的后序遍历
 public static void lrn2(Node head){
        if(head==null){
            return;
        }
        Stack<Node> stack1=new Stack<>();
        Stack<Node> stack2=new Stack<>();
        stack1.push(head);
        while (!stack1.empty()){
            Node tmp=stack1.peek();
            stack1.pop();
            stack2.push(tmp);
            if(tmp.leftNode!=null){
                stack1.push(tmp.leftNode);
            }
            if(tmp.rightNode!=null){
                stack1.push(tmp.rightNode);
            }
        }
       while (!stack2.empty()){
           System.out.print(stack2.pop().value + "	");
       }
    }

 参考：http://noalgo.info/832.html

 更多代码：

import java.util.*;

/**
 * Created by hfz on 2016/7/5.
 */
public class traversal {
    static int step=0;
    public static void main(String[] args){
        int[] nodeArray=new int[]{1,2,4,-1,-1,5,-1,-1,3,-1,6,-1,-1};
        int[] nodeArray2=new int[]{1,2,4,-1,-1,5,9,-1,-1,-1,3,6,7,-1,8,-1,-1,-1,-1};
        Node root=new Node();
        root=createBinaryTree(root,nodeArray);
        System.out.println("tree A:");
        System.out.println("先序遍历:");
        nlr(root);

        System.out.println("
" + "非递归先序遍历：");
        unRecurNLR(root);
        nlr2(root);


        System.out.println("
" + "中序遍历：");
        lnr(root);

        System.out.println("
" + "非递归中序遍历：");
        unRecurLNR2(root);



        System.out.println("
" + "后序遍历：");
        lrn(root);
        System.out.println("
" + "层次遍历：");
        levelTraversal(root);
        System.out.printf("%n二叉树叶子节点数量%n%d", getLeafNodeNum(root));



        System.out.println("
" + "二叉树节点总个数：");
        System.out.print(calNodeAmounts(root));
        System.out.println("
" + "二叉树深度：");
        int i=0;
        System.out.print(calDepth(root, i));
        int k=2;
        System.out.printf("%n第1层到第%d层节点总个数%n",k);
        System.out.print(calKLevalNodeAmounts(root, k, 1));
        System.out.print(String.format("%n第%d层节点个数为%n%d", k, calKthLevel(root, k)));





        Node root2=new Node();
        step=0;
        root2=createBinaryTree(root2,nodeArray2);
        System.out.println("
"+"tree B:");
        System.out.println("先序遍历:");
        nlr(root2);
        System.out.println("
" + "非递归先序遍历：");
        unRecurNLR(root2);
        System.out.println("
" + "中序遍历：");
        lnr(root2);

        System.out.println("
" + "非递归中序遍历：");
        unRecurLNR2(root2);


        System.out.println("
" + "后序遍历：");
        lrn(root2);
        System.out.println("
" + "层次遍历：");
        levelTraversal(root2);
        System.out.printf("%n二叉树叶子节点数量%n%d", getLeafNodeNum(root2));

        System.out.println("
" + "二叉树节点个数：");
        System.out.print(calNodeAmounts(root2));
        System.out.println("
" + "二叉树深度：");
        System.out.print(calDepth(root2, i));
        k=4;
        System.out.print(String.format("%n第1层到第%d层节点总个数为:%n%d", k, calKLevalNodeAmounts(root2, k, 1)));
        System.out.print(String.format("%n第%d层节点个数为:%n%d", k, calKthLevel(root2, k)));

        System.out.printf("%ntree A和tree B 结构是否相同：%n%b",structureCmp(root,root2));

    }
    // 创建二叉树
    public static Node createBinaryTree(Node root,int[] nodeArray ){
        int val=-1;
        try {
            val = nodeArray[step];
            step++;
        }
        catch (ArrayIndexOutOfBoundsException ex){
            System.out.println("(ArrayIndexOutOfBounds,check the nodeArray");
        }
        if(val<0){
            //System.out.println("leaf node");
            root=null;
            return root;
        }
        root=new Node(val);///指向新对象
        //step++;
        root.leftNode=createBinaryTree(root.leftNode,nodeArray);
        root.rightNode=createBinaryTree(root.rightNode,nodeArray);
        return root;
    }
    //先序遍历
    public static void nlr(Node head){
        if(head==null){
            return;
        }
        System.out.print(head.value+"	");
        nlr(head.leftNode);
        nlr(head.rightNode);
    }
    //非递归形式的先序遍历
    /*
    1）申请一个栈来存放节点，首先存入根节点
    2）弹出栈顶节点并打印其值，记为cur，将栈顶节点(cur)的右节点（如果有的话）入栈，将栈顶节点(cur)的左节点入栈
    3）重复2，直至栈为空
     */
    public static void unRecurNLR(Node root){
        Stack<Node> stack=new Stack<>();
        Node cur=root;
        Node rightNode=null;
        Node leftNode=null;
        if(cur==null){
            return;
        }
        stack.push(cur);
        while(!stack.empty()){
            cur=stack.pop();
            System.out.print(cur.value + "	");
            rightNode=cur.rightNode;
            leftNode=cur.leftNode;
            if(rightNode!=null){
                stack.push(rightNode);
            }
            if(leftNode!=null){
                stack.push(leftNode);
            }
        }
    }

    public static void nlr2(Node head){
        Stack<Node> stack=new Stack<>();
        ArrayList<Integer> list=new ArrayList<>();
        stack.push(head);
        while (!stack.empty()){
            Node temp=stack.peek();
            list.add(temp.value);
            stack.pop();
            if(temp.rightNode!=null){
                stack.push(temp.rightNode);
            }
            if(temp.leftNode!=null){
                stack.push(temp.leftNode);
            }
        }
        Integer[] rr=list.toArray(new Integer[]{} );
        System.out.println(Arrays.toString(rr));
    }










    //中序遍历
    public static void lnr(Node head){
        if(head==null){
            return;
        }
        lnr(head.leftNode);
        System.out.print(head.value + "	");
        lnr(head.rightNode);
    }

    //非递归形式的中序遍历(自己编写)
    /*
    1)申请栈存放节点，令cur=head
    2)将cur指向的节点入栈
    3)令cur=cur.leftNode，如果cur！=null，转2，如果栈为空，算法结束，否则弹出cur指向的节点（栈顶节点）node，并打印node
    4)弹出栈顶节点后，令cur=node.right，转2
     */

    public static void unRecurLNR(Node head){
        Node cur=head;
        //Node leftNode=null;
        //Node rightNode=null;
        Stack<Node> stack=new Stack<>();
        stack.push(cur);
        while (!stack.empty()){
            while (cur!=null) {
                cur=cur.leftNode;
                if(cur!=null)
                stack.push(cur);
            }
            cur=stack.pop();
            System.out.print(cur.value+"	");
            cur=cur.rightNode;
            if(cur!=null)
                stack.push(cur);

        }

    }
    //非递归形式的中序遍历(书上编写)，形式更加简洁。

    public static void unRecurLNR2(Node head){
        if(head!=null){
            Node cur=head;
            Stack<Node> stack=new Stack<>();
            //stack.push(cur);
            while (!stack.empty()||cur!=null){
                if(cur!=null){
                    stack.push(cur);
                    cur=cur.leftNode;
                }
                else{
                    cur=stack.pop();
                    System.out.print(cur.value+"	");
                    cur=cur.rightNode;
                }
            }

        }
    }







    //后序遍历
    public static void lrn(Node head){
        if(head==null){
            return;
        }
        lrn(head.leftNode);
        lrn(head.rightNode);
        System.out.print(head.value + "	");
    }
    //层次遍历
    public static void levelTraversal(Node head){
        Queue<Node> nodeQueue=new LinkedList<>();
        nodeQueue.offer(head);
        while(!nodeQueue.isEmpty()){
            Node node=nodeQueue.poll();
            System.out.print(node.value+"	");
            if (node.leftNode!=null){
                nodeQueue.offer(node.leftNode);
            }
            if(node.rightNode!=null){
                nodeQueue.offer(node.rightNode);
            }
        }
        return;
    }
    //计算二叉树节点总个数
    public static int calNodeAmounts(Node head){
        if(head==null){
            return 0;
        }
        return calNodeAmounts(head.leftNode)+calNodeAmounts(head.rightNode)+1;
    }
    //计算二叉树深度(自己编写)
    public static int calDepth(Node head,int counter){
        if(head==null){
            return counter;
        }
        else {
            counter++;
        }
        int a=calDepth(head.leftNode,counter);
        int b=calDepth(head.rightNode,counter);
        return a>b?a:b;
    }
    //计算二叉树深度（更好实现）
    public static int calDept2(Node head){
        if(head==null){
            return 0;
        }
        int leftDepth=calDept2(head.leftNode);
        int rightDepth=calDept2(head.rightNode);
        return leftDepth>rightDepth?leftDepth+1:rightDepth+1;
    }

    //第1层到第k层节点总数量（自己编写）

    public static int calKLevalNodeAmounts(Node head,int KLevel,int currentLevel){

        if(head==null){
            return 0;
        }
        if(currentLevel<= KLevel){
            return calKLevalNodeAmounts(head.leftNode,KLevel,currentLevel+1)+calKLevalNodeAmounts(head.rightNode,
                    KLevel,currentLevel+1)+1;
        }
        return 0;
    }
    //第k层节点数量
    public static int calKthLevel(Node head,int k){
        if(head==null||k<1){
            return 0;
        }
        if(k==1){
            return 1;
        }
        int leftAmounts=calKthLevel(head.leftNode,k-1);
        int rightAmounts=calKthLevel(head.rightNode,k-1);
        return leftAmounts+rightAmounts;
    }
    //计算叶子节点个数
    public static int getLeafNodeNum(Node head){
        if(head==null){
            return 0;
        }
        if(head.leftNode==null&&head.rightNode==null){
            return 1;
        }
        int leftNum=getLeafNodeNum(head.leftNode);
        int rightNum=getLeafNodeNum(head.rightNode);
        return leftNum+rightNum;
    }

    //判断两个二叉树结构是否相同
    public static boolean structureCmp(Node head1,Node head2){
        if(head1==null&&head2==null){
            return true;
        }
        else if(head1==null||head2==null){
            return false;
        }
        boolean leftResult=structureCmp(head1.leftNode,head2.leftNode);
        boolean rightResult=structureCmp(head1.rightNode,head2.rightNode);
        return leftResult&&rightResult;
    }

    //求二叉树的镜像
    public static Node Mirror(Node head){
        if(head==null){
            return null;
        }

        Node leftNode=Mirror(head.leftNode);
        Node rightNode=Mirror(head.rightNode);
        head.leftNode=rightNode;
        head.rightNode=leftNode;
        return head;
    }

}
class Node{
    public int value=-1;
    public Node leftNode;
    public Node rightNode;
    public Node(int val){
        value=val;
    }
    public Node(){
    }
}