二叉树结构

首先，二叉树是一个数据结果，以节点子节点存储数据的数据结构，只能有一个根节点，每个节点最多只能有两个节点，依次下推

参照下图：

 

首先说明，二叉树没有什么原理，一个根节点，最多只能分配两个子节点，也可以有一个子节点，分别叫做的叫满（完全）二叉树和左子树，右子树

常见的问题就是遍历 了，咱们都是搞程序编程的，如果以程序的方式遍历这个数据，并且按照一定形式输出，

三种方式

先序：根左右

 

中序遍历：左根右

 

后序遍历：左右根

 

 

1. 应用场景：输出某个文件夹下所有文件名称(可以有子文件夹)—用先序遍历实现。
2. 统计某个文件夹的大小（该文件夹下所有文件的大小）–用后序遍历实现。

 

 

public class Node {
		//数据名称
		private int data;  
		//左侧子节点
	    private Node leftNode;  
	    //右侧子节点
	    private Node rightNode;  
	    //有参构造函数
	    public Node(int data, Node leftNode, Node rightNode){  
	        this.data = data;  
	        this.leftNode = leftNode;  
	        this.rightNode = rightNode;  
	    }  
//此处省略 get set方法（程序编写，注意需要生成）

public class BinaryTree {
	
	 /** 
     * @author yaobo
     * 二叉树的先序中序后序排序 
     */  
    public Node init() {//注意必须逆序建立，先建立子节点，再逆序往上建立，因为非叶子结点会使用到下面的节点，而初始化是按顺序初始化的，不逆序建立会报错  
        Node J = new Node(8, null, null);  
        Node H = new Node(4, null, null);  
        Node G = new Node(2, null, null);
        Node F = new Node(7, null, J);
        Node E = new Node(5, H, null);  
        Node D = new Node(1, null, G);  
        Node C = new Node(9, F, null);  
        Node B = new Node(3, D, E);  
        Node A = new Node(6, B, C);  
        
        return A;   //返回根节点  
    }
    //输出节点信息
    public void printNode(Node node){
        System.out.print(node.getData());  
    }  
    
    //先序遍历  
    public void theFirstTraversal(Node root) {
        printNode(root);  
        if (root.getLeftNode() != null) {  //使用递归进行遍历左孩子  
            theFirstTraversal(root.getLeftNode());  
        }  
        if (root.getRightNode() != null) {  //递归遍历右孩子  
            theFirstTraversal(root.getRightNode());  
        }  
    }  
    //中序遍历  
    public void theInOrderTraversal(Node root) {
        if (root.getLeftNode() != null) {  
            theInOrderTraversal(root.getLeftNode());  
        }  
        printNode(root);  
        if (root.getRightNode() != null) {  
            theInOrderTraversal(root.getRightNode());  
        }  
    }
    
    //后序遍历  
    public void thePostOrderTraversal(Node root) { 
        if (root.getLeftNode() != null) {  
            thePostOrderTraversal(root.getLeftNode());  
        }  
        if(root.getRightNode() != null) {  
            thePostOrderTraversal(root.getRightNode());  
        }  
        printNode(root);  
    }  
     
    //调用
    public static void main(String[] args) {  
        BinaryTree tree = new BinaryTree();  
        Node root = tree.init();  
        System.out.println("明瑞：先序遍历");  
        tree.theFirstTraversal(root);  
        System.out.println("");  
        System.out.println("明瑞：中序遍历");  
        tree.theInOrderTraversal(root);  
        System.out.println("");  
        System.out.println("明瑞：后序遍历");  
        tree.thePostOrderTraversal(root);  
        System.out.println("");  
        
    }  

结果

明瑞：先序遍历
631254978
明瑞：中序遍历
123456789
明瑞：后序遍历
214538796