[数据结构]--二叉树以及Java实现

二叉树

树的定义

树是由根结点和若干颗子树构成的。树是由一个集合以及在该集合上定义的一种关系构成的。集合中的元素称为树的结点，所定义的关系称为父子关系。父子关系在树的结点之间建立了一个层次结构。在这种层次结构中有一个结点具有特殊的地位，这个结点称为该树的根结点，或称为树根。

树的关键字

• 节点的度：一个节点含有的子树的个数称为该节点的度；
• 叶节点或终端节点：度为0的节点称为叶节点；
• 非终端节点或分支节点：度不为0的节点；
• 双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；
• 孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；
• 兄弟节点：具有相同父节点的节点互称为兄弟节点；
• 树的度：一棵树中，最大的节点的度称为树的度；
• 节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
• 树的高度或深度：树中节点的最大层次；
• 堂兄弟节点：双亲在同一层的节点互为堂兄弟；
• 节点的祖先：从根到该节点所经分支上的所有节点；
• 子孙：以某节点为根的子树中任一节点都称为该节点的子孙。
• 森林：由m（m>=0）棵互不相交的树的集合称为森林；

java中的实现

/**
 * 二叉树
 * 
 * @author ccj
 *
 */
public class Tree<E> {
    //根节点
    private Node<E> root;

    public Node<E> getRoot() {
        return root;
    }


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


    /**
     * 插入节点
     * @param e
     */
    public void insert(E e){
        Node<E> newNode=new Node<E>(e);//即将插入的新节点

        Node<E> current =root;//current 代表当前节点
        Node<E> parent;//父节点

        if(root==null){
            root =newNode;
            return;
        }else{
            //新数据 连续和当前节点的数据作比较
            //,新数据小的,往左查找;大的往右查找
            while(true){
                //父节点 一直在改变
                parent=current;
                //如果current.data 大于e
                if(compare(current.data, e)){
                    //向左遍历,此时current变为current.leftChild;
                    current=current.leftChild;
                    //如果此时的current 为null,将父节点的left赋值为newNode,返回
                    if(current==null){
                        parent.leftChild=newNode;
                        return;
                    }
                }else{
                    current=current.rightChild;
                    if(current==null){
                        parent.rightChild=newNode;
                        return;
                    }
                }
            }

        }

    }


    /**
     * 删除
     * @param e
     */
    public boolean delete(E e){
        //当前节点
        Node<E> current=root;
        //当前节点的父节点
        Node<E> parent ;
        while(true){
            if(current==null){
                return false;
            }

            if(current.data!=e){
                //左遍历
                if(compare(current.data,e)){
                    parent=current;
                    current=parent.leftChild;
                    if(current.data==e){
                        current=null;
                        parent.leftChild=current.leftChild;
                        return true;
                    }
                }else{
                    //右遍历
                        parent=current;
                        current=parent.rightChild;
                        if(current.data==e){
                            current=null;
                            parent.leftChild=current.leftChild;
                            return true;
                        }
                }
            }else{
                root=null;
                root.leftChild=null;
                root.rightChild=null;
            }
        }
    }
    /**
     * 
     * @param e
     */
    public void change(E e){

    }
    /**
     * 
     * @param e
     */
    public Node<E> find(E e){
        //引用当前节点,从根节点开始
        Node<E> current =root;
        while(true){
            if(current==null){
                return null;
            }
            if(current.data!=e){
                //左遍历
                if(compare(current.data,e)){
                    current=current.leftChild;
                    if(current.data==e){
                        return current;
                    }
                }else{
                    //右遍历
                        current=current.rightChild;
                        if(current.data==e){
                            return current;
                        }
                }
            }
        }
    }

    /**
     * 比较器(用int 来比较 ,可扩展)
     * @param newValue
     * @param oldValue
     * @return
     */
    private boolean compare(E newValue,E oldValue){

        if(Integer.parseInt(newValue+"")>Integer.parseInt(oldValue+"")){
            System.out.println(newValue +"大于"+oldValue);
            return true;
        }else
            System.out.println(newValue +"小于"+oldValue);
            return false;


    }
    /**
     * 遍历输出
     */
    public void display(){


    }
    /**
     * 前序遍历
     * 根节点->左子树->右子树
     * @param localNode
     */
    public void frontOder(Node<E> localNode){
        //
        if(localNode!=null){
            //输出节点 
            System.out.println("frontOder.data==>"+localNode.getData());
            //遍历节点的值: 输出节点 输出节点的佐治 ....
            frontOder(localNode.leftChild);
            //遍历节点的值:输出节点 输出节点右值....

            frontOder(localNode.rightChild);
            return;
        }
    }

    /**
     * 中序遍历
     * 左子树->根节点->右子树  
     * 从小到大排序
     * @param localNode
     */
    public void inOder(Node<E> localNode){
        //
        if(localNode!=null){
            inOder(localNode.leftChild);
            System.out.println("inOder.data==>"+localNode.getData());
            inOder(localNode.rightChild);
            return;
        }
    }

    /**
     * 后续遍历
     * 左子树->根节点->右子树  
     * 从小到大排序
     * @param localNode
     */
    public void lastOder(Node<E> localNode){
        //
        if(localNode!=null){
            inOder(localNode.leftChild);
            inOder(localNode.rightChild);
            System.out.println("inOder.data==>"+localNode.getData());
            return;
        }
    }



    /**
     * 树节点
     * 
     * @author ccj
     *
     * @param <E>
     */
    static class Node<E>{

        private E data;

        //左子节点
        private Node<E> leftChild;

        //右子节点
        private Node<E> rightChild;


        public Node(E data){
            this.data=data;
        }





        public E getData() {
            return data;
        }


        public void setData(E data) {
            this.data = data;
        }


        public Node<E> getLeftChild() {
            return leftChild;
        }


        public void setLeftChild(Node<E> leftChild) {
            this.leftChild = leftChild;
        }


        public Node<E> getRightChild() {
            return rightChild;
        }


        public void setRightChild(Node<E> rightChild) {
            this.rightChild = rightChild;
        }


    }

/*******************测试入口*************/

    public static void main(String[] args) {
        // TODO Auto-generated method stub


        treeTest();
    }
    private static void treeTest() {
        System.out.println("--自定义树---");
        System.out.println("--增加---");
        tree.insert(1);
        tree.insert(2);
        tree.insert(3);
        tree.insert(4);
        tree.insert(5);
        tree.insert(6);
        System.out.println("--查找---");
        System.out.println("--已经找到---"+tree.find(2).getData());
        System.out.println("--删除---");
        tree.delete(2);

        System.out.println("--前序遍历---");
        tree.frontOder(tree.getRoot().getRightChild());
        System.out.println("--中序遍历---");
        tree.frontOder(tree.getRoot());

    }

}