二叉树遍历-面试常见题

import javax.sound.midi.Sequence;
import java.util.LinkedList;
import java.util.Queue;


public class TreeTest {


    private static Queue<BinaryTreeNode> queue = new LinkedList<BinaryTreeNode>();


    public static void main(String[] args) {
        BinaryTreeNode nodeA = new BinaryTreeNode("nodeA", -3);
        BinaryTreeNode nodeB = new BinaryTreeNode("nodeB", 1);
        BinaryTreeNode nodeC = new BinaryTreeNode("nodeC", 2);
        BinaryTreeNode nodeD = new BinaryTreeNode("nodeD",5);
        BinaryTreeNode nodeE = new BinaryTreeNode("nodeE", -1);
        BinaryTreeNode nodeF = new BinaryTreeNode("nodeF", 2);
        BinaryTreeNode nodeG = new BinaryTreeNode("nodeG", -2);
        BinaryTreeNode nodeH = new BinaryTreeNode("nodeH", -2);
        BinaryTreeNode nodeI = new BinaryTreeNode("nodeI", 2);


        nodeA.lNode = nodeB;
        nodeA.rNode = nodeC;


        nodeB.lNode = nodeD;
        nodeB.rNode = nodeE;


        nodeC.lNode = nodeF;
        nodeC.rNode = nodeG;


        nodeD.lNode = nodeH;
        nodeD.rNode = nodeI;


        // 二叉树中节点的个数
        System.out.println(getCountOfNode(nodeA));
        System.out.println("深度A = " + depth(nodeA));
        System.out.println("--------------前序遍历结果--------------");
        preOrderTraverse(nodeA);
        System.out.println("--------------中序遍历结果--------------");
        inOrderTraverse(nodeA);
        System.out.println("--------------后序遍历结果--------------");
        postOrderTraverse(nodeA);
        System.out.println("--------------广度遍历--------------");
        levelTraverse(nodeA);
        System.out.println("--------------K层节点个数--------------");
        System.out.println(getNodeNumKthLevel(nodeA, 3));
    }


    /**
     * 求二叉树中节点的个数
     */
    public static int getCountOfNode(BinaryTreeNode node) {
        if (node == null) {
            return 0;
        }
        return getCountOfNode(node.lNode) + getCountOfNode(node.rNode) + 1;
    }


    /**
     * 求二叉树的深度
     */
    public static int depth(BinaryTreeNode node) {
        if (node == null) {
            return 0;
        }


        return Math.max(depth(node.lNode), depth(node.rNode)) + 1   ;
    }


    /**
     * 前序遍历
     */
    public static void preOrderTraverse(BinaryTreeNode node) {
        if (node == null) {
            return;
        }
        visit(node);
        preOrderTraverse(node.lNode);
        preOrderTraverse(node.rNode);
    }


    /**
     * 中序遍历
     */
    public static void inOrderTraverse(BinaryTreeNode node) {
        if (node == null) {
            return;
        }


        inOrderTraverse(node.lNode);
        visit(node);
        inOrderTraverse(node.rNode);
    }


    /**
     * 后序遍历
     */
    public static void postOrderTraverse(BinaryTreeNode node) {
        if (node == null) {
            return;
        }


        postOrderTraverse(node.lNode);
        postOrderTraverse(node.rNode);
        visit(node);
    }


    public static void levelTraverse(BinaryTreeNode node) {
        if (node == null) {
            return;
        }


        queue.add(node);
        while (!queue.isEmpty()) {
            BinaryTreeNode n = (BinaryTreeNode) queue.poll();
            visit(n);
            if (n.lNode != null) {
                queue.add(n.lNode);
            }
            if (n.rNode != null) {
                queue.add(n.rNode);
            }
        }
        return;
    }


    /**
     *  K层节点个数
     */


    public  static int getNodeNumKthLevel(BinaryTreeNode  pRoot, int k)
    {
        if(pRoot == null || k < 1)
            return 0;
        if(k == 1)
            return 1;
        int numLeft = getNodeNumKthLevel(pRoot.lNode, k - 1); // 左子树中k-1层的节点个数
        int numRight = getNodeNumKthLevel(pRoot.rNode, k - 1); // 右子树中k-1层的节点个数
        return (numLeft + numRight);
    }




    /**
     * 访问节点
     */
    public static void visit(BinaryTreeNode node) {
        if (node == null) return;
        System.out.println(node.name + ".value = " + node.value);
    }
}


class BinaryTreeNode {
    public String name;
    public int value;
    public BinaryTreeNode lNode;
    public BinaryTreeNode rNode;


    BinaryTreeNode(String name, int value) {
        this.name = name;
        this.value = value;
    }
}