数据结构(5):Java实现二叉树

　　　　

　　二叉树图:

　　　　

package com.test.Sort;

import java.util.ArrayList;
import java.util.LinkedList;

public class Binary_Tree {
    //java实现二叉树实现
    public static void main(String[] args) {
        Tree t =new Tree();
        t.add("A");
        t.add("B");
        t.add("C");
        Node root = t.getRoot();
        //先序遍历
        System.out.println("先序遍历:");
        t.Preorder(root);
        System.out.println("------------------------");
        //中序遍历
        System.out.println("中序遍历:");
        t.inOrder(root);
        System.out.println("------------------------");
        //后序遍历
        System.out.println("后序遍历:");
        t.postOrder(root);
    }

}

//节点类
class Node{
    //头节点
    private String node;
    //左节点
    private Node iLnode;
    //右节点
    private Node iRnode;

    public Node(String node){
        this.node = node;
    }

    public String getNode() {
        return node;
    }

    public void setNode(String node) {
        this.node = node;
    }

    public Node getiLnode() {
        return iLnode;
    }

    public void setiLnode(Node iLnode) {
        this.iLnode = iLnode;
    }

    public Node getiRnode() {
        return iRnode;
    }

    public void setiRnode(Node iRnode) {
        this.iRnode = iRnode;
    }
}

//创建二叉树
class Tree{
    private Node root;
    public Tree(){};

    public Node getRoot() {
        return root;
    }

    public void setRoot(Node root) {
        this.root = root;
    }

    /**
     *
     * 递归实现先序遍历
     * 先序遍历 在先序遍历中，我们先访问根节点，然后递归使用先序遍历访问左子树，再递归使用先序遍历访问右子树
     * 根节点->左子树->右子树
     *     他的顺序是:
     *         A
     *      B     C
     *
     * 先序遍历是:A为根节点,左子数节点B,右子数节点C
     * **/
    public void Preorder(Node node){
        //如果先序遍历的根节点是空的,直接退出
        if(node==null)
            return;
        System.out.println(node.getNode());
        Preorder(node.getiLnode());
        Preorder(node.getiRnode());
    }


    /**
     * 中序遍历
     *
     * 中序遍历:左子数节点B,A为根节点,右子数节点C
     *
     * **/
    public void inOrder(Node node){
        //如果先序遍历的根节点是空的,直接退出
        if(node==null)
            return;
        inOrder(node.getiLnode());
        System.out.println(node.getNode());
        inOrder(node.getiRnode());
    }

    /**
     * 后序遍历
     * 后序遍历:左子数节点B,右子数节点C,A为根节点,
     *
     * **/
    public void postOrder(Node node){
        //如果先序遍历的根节点是空的,直接退出
        if(node==null)
            return;
        postOrder(node.getiLnode());
        postOrder(node.getiRnode());
        System.out.println(node.getNode());
    }


    public void add(String elem){
        Node node = new Node(elem);
        //如果二叉树节点是空的
        if(root==null){
            //把传递进去的node传递给root,此时root有数据
            root = node;
            return;
        }else{
            //定义个list列表
            LinkedList linkedList =new LinkedList();
            //列表中添加root节点数据
            linkedList.add(root);
            //如果列表不为空
            while(!linkedList.isEmpty()){
                //移出第一个元素
                Node element  = (Node) linkedList.pop();
                if(element.getiLnode()==null){
                    //左节点为空,设置左节点
                    element.setiLnode(node);
                    return;
                }else if(element.getiRnode()==null){
                    //右节点为空,设置右节点
                    element.setiRnode(node);
                    return;
                }else{
                     //如果左右子树都不为空，继续加入数据
                    linkedList.add(element.getiLnode());
                    linkedList.add(element.getiRnode());
                }
            }
        }
    }
}

　　　输出:

　　　　

　　一个抽象概念:　　

　　　　

同一个对象调用方法
以二叉树为例:
只有add方法,当add(a)时, 那么此时头节点就是a,当add(b)的时候，头节点不会是b，b只能左节点和右节点。

如果是不同的对象调用add方法,那么头节点是a也可以是b
原理:同一个对象之间数据互相影响
不同对象的之间互不干涉