二叉树学习总结

二叉树遍历有三种方式

• 先序遍历

  • 先访问根节点，然后访问左节点，最后访问右节点(根->左->右)

• 中序遍历

  • 先访问左节点，然后访问根节点，最后访问右节点(左->根->右)

• 后序遍历

  • 先访问左节点，然后访问右节点，最后访问根节点(左->右->根)

package ace;
public class TreeNode {
	// 左节点(儿子)
    private TreeNode lefTreeNode;
    // 右节点(儿子)
    private TreeNode rightNode;
    // 数据
    private int value;
    public TreeNode(int value) {
        this.value = value;
    }
    public TreeNode getLefTreeNode() {
		return lefTreeNode;
	}
	public void setLefTreeNode(TreeNode lefTreeNode) {
		this.lefTreeNode = lefTreeNode;
	}
	public TreeNode getRightNode() {
		return rightNode;
	}
	public void setRightNode(TreeNode rightNode) {
		this.rightNode = rightNode;
	}
	public int getValue() {
		return value;
	}
	public void setValue(int value) {
		this.value = value;
	}
	public static void main(String[] args) {
        //根节点-->10
        TreeNode treeNode1 = new TreeNode(10);
        //左孩子-->9
        TreeNode treeNode2 = new TreeNode(9);
        //右孩子-->20
        TreeNode treeNode3 = new TreeNode(20);
        //20的左孩子-->15
        TreeNode treeNode4 = new TreeNode(15);
        //20的右孩子-->35
        TreeNode treeNode5 = new TreeNode(35) ; 
        //根节点的左右孩子
        treeNode1.setLefTreeNode(treeNode2);
        treeNode1.setRightNode(treeNode3);
        //20节点的左右孩子
        treeNode3.setLefTreeNode(treeNode4);
        treeNode3.setRightNode(treeNode5);
        preTraverseBTree(treeNode1);
        System.out.println("在下小脑斧，上边为先序遍历结果");
        inTraverseBTree(treeNode1);
        System.out.println("在下小团团，上边为中序遍历结果");   
    }
	 /**
     * 先序遍历
     * @param rootTreeNode  根节点
     */
    public static void preTraverseBTree(TreeNode rootTreeNode) {
        if (rootTreeNode != null) {
            //访问根节点
            System.out.println(rootTreeNode.getValue());
            //访问左节点
            preTraverseBTree(rootTreeNode.getLefTreeNode());
            //访问右节点
            preTraverseBTree(rootTreeNode.getRightNode());
        }
    }
    /**
     * 中序遍历
     * @param rootTreeNode  根节点
     */
    public static void inTraverseBTree(TreeNode rootTreeNode) {
        if (rootTreeNode != null) {
            //访问左节点
            inTraverseBTree(rootTreeNode.getLefTreeNode());
            //访问根节点
            System.out.println(rootTreeNode.getValue());
            //访问右节点
            inTraverseBTree(rootTreeNode.getRightNode());
        }
    }
}

运行结果为：

10
9
20
15
35
在下小脑斧，上边为先序遍历结果
9
10
15
20
35
在下小团团，上边为中序遍历结果
 

创建动态二叉树(当前根节点的左边全部比根节点小，当前根节点的右边全部比根节点大)、查询二叉树的深度、找出二叉树的最大值。

package ace;
import ace.TreeNode;
public class TreeRoot {
	public static TreeNode treeRoot;
    public TreeNode getTreeRoot() {
        return treeRoot;
    }
    public void setTreeRoot(TreeNode treeRoot) {
        this.treeRoot = treeRoot;
    }
    /**
     * 动态创建二叉查找树
     *当前根节点的左边全部比根节点小，当前根节点的右边全部比根节点大。
     * @param treeRoot 根节点
     * @param value    节点的值
     */
    public static void createTree(TreeRoot treeRoot, int value) {

        //如果树根为空(第一次访问)，将第一个值作为根节点
        if (treeRoot.getTreeRoot() == null) {
            TreeNode treeNode = new TreeNode(value);
            treeRoot.setTreeRoot(treeNode);
        } else  {
            //当前树根
            TreeNode tempRoot = treeRoot.getTreeRoot();
            while (tempRoot != null) {
                //当前值大于根值，往右边走
                if (value > tempRoot.getValue()) {
                    //右边没有树根，那就直接插入
                    if (tempRoot.getRightNode() == null) {
                        tempRoot.setRightNode(new TreeNode(value));
                        return ;
                    } else {
                        //如果右边有树根，到右边的树根去
                        tempRoot = tempRoot.getRightNode();
                    }
                } else {
                    //左没有树根，那就直接插入
                    if (tempRoot.getLefTreeNode() == null) {
                        tempRoot.setLefTreeNode(new TreeNode(value));
                        return;
                    } else {
                        //如果左有树根，到左边的树根去
                        tempRoot = tempRoot.getLefTreeNode();
                    }
                }
            }
        }
    }
    /**
     * 
     * 查询二叉树的深度
     * @param args
     */
    public static int getHeight(TreeNode treeNode) {
        if (treeNode == null) {
            return 0;
        } else {
            //左边的子树深度
            int left = getHeight(treeNode.getLefTreeNode());
            //右边的子树深度
            int right = getHeight(treeNode.getRightNode());
            int max = left;
            if (right > max) {
                max = right;
            }
            return max + 1;
        }
    }
    /**
     * 找出树的最大值
     *
     * @param rootTreeNode
     */
    public static int  getMax(TreeNode rootTreeNode) {
        if (rootTreeNode == null) {
            return -1;
        } else {
            //找出左边的最大值
            int left = getMax(rootTreeNode.getLefTreeNode());
            //找出右边的最大值
            int right = getMax(rootTreeNode.getRightNode());
            //与当前根节点比较
            int currentRootValue = rootTreeNode.getValue();
            //假设左边的最大
            int max = left;
            if (right > max) {
                max = right;
            }
            if (currentRootValue > max) {
                max = currentRootValue;
            }
            return max ;
        }
    }
    public static void main(String[] args) {
    int[] arrays = {2, 3, 1, 4, 5};
    //动态创建树
    TreeRoot root = new TreeRoot();
    for (int value : arrays) {
        TreeRoot.createTree(root, value);
        }
    System.out.println(root.getTreeRoot());
    //中序遍历树
    TreeNode.inTraverseBTree(root.getTreeRoot());
    System.out.println("在下小团团1");
    //先序遍历树
    TreeNode.preTraverseBTree(root.getTreeRoot());
    System.out.println("在下小团团2");
   System.out.println(getHeight(treeRoot));
   System.out.println(getMax(treeRoot));
    }  
}

 

运行结果为：

 ace.TreeNode@15db9742
1
2
3
4
5
在下小团团1
2
1
3
4
5
在下小团团2
4
5
参考自java3y