二叉树(添加,删除,查找,获取,遍历等)的java实现

  时间:2018-11-19
本文章向大家介绍二叉搜索树Java实现(增删改查遍历等操作),需要的朋友可以参考一下

  一段来自百度百科的对二叉树的解释:

  在计算机科学中,二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”(left subtree)和“右子树”(right subtree)。二叉树常被用于实现二叉查找树和二叉堆。
  一棵深度为k,且有2^k-1个节点的二叉树,称为满二叉树。这种树的特点是每一层上的节点数都是最大节点数。而在一棵二叉树中,除最后一层外,若其余层都是满的,并且最后一层或者是满的,或者是在右边缺少连续若干节点,则此二叉树为完全二叉树。具有n个节点的完全二叉树的深度为floor(log2n)+1。深度为k的完全二叉树,至少有2k-1个叶子节点,至多有2k-1个节点。
  二叉树的结构:

  二叉树节点的声明:

static final class Entry<T extends Comparable<T>>{
        //保存的数据
        private T item;
        //左子树
        private Entry<T> left;
        //右子树
        private Entry<T> right;
        //父节点
        private Entry<T> parent;
        Entry(T item,Entry<T> parent){
            this.item = item;
            this.parent = parent;
        }
    }

  类属性:

 //根节点
    private Entry<T> root;
    //数据量
    private int size = 0;

  二叉树添加数据:

/**
     * 添加元素
     * @param item 待添加元素
     * @return 已添加元素
     */
    public T put(T item){
        //每次添加数据的时候都是从根节点向下遍历
        Entry<T> t = root;
  if (t == null){
            //当前的叉树树的为空,将新节点设置为根节点,父节点为null
            root = new Entry<>(item,null);
       size++; 
            return root.item;
        }
        //自然排序结果,如果传入的数据小于当前节点返回-1,大于当前节点返回1,否则返回0
        int ret = 0;
        //记录父节点
        Entry<T> p = t;
        while (t != null){
            //与当前节点比较
            ret = item.compareTo(t.item);
            p = t;
            //插入节点比当前节点小,把当前节点设置为左子节点,然后与左子比较,以此类推找到合适的位置
            if (ret < 0)
                t = t.left;
            //大于当前节点
            else if (ret > 0)
                t = t.right;
            else {
                //相等就把旧值覆盖掉
                t.item = item;
                return t.item;
            }
        }
        //创建新节点
        Entry<T> e = new Entry<>(item,p);
        //根据比较结果将新节点放入合适的位置
        if (ret < 0)
            p.left = e;
        else
            p.right = e;
     size++;
        return e.item;
    }

   在put的过程中,使用Comparable<T>中的compareTo来比较两个元素的大小的,所以在二叉树中存储的元素必须要继承Comparable<T> 类,覆写compareTo方法。

 

  二叉树删除数据

/**
     * 删除元素
     * 删除元素如果细分的话,可以分为4中:没有子节点,只有左节点,只有右节点,有两个子节点
     * 1)没有子节点这种情况比较简单,直接删除就可以了
     * 2)只有左节点或右节点,这两种情况处理方式是一致的,只是方向相反,所以在一起讲了,
     * 将删除节点的父节点的左节点(右节点)指向删除节点的子节点,将左节点(右节点)指向删除节点的父节点
     * 3)有两个子节点,这种情况相对来说比较复杂一点:
     * 找到删除节点的前驱节点或后继节点,然后将前驱或后继节点的值赋给删除节点,然后将前驱或后继节点删除。本质是删除前驱或后继节点
     * 前驱节点的特点:
     * 1)删除的左子节点没有右子节点,那么左子节点即为前驱节点
     * 2)删除节点的左子节点有右子节点,那么最右边的最后一个节点即为前驱节点
     * 后继节点的特点:
     * 与前驱节点刚好相反,总是右子节点,或则右子节点的最左子节点;例如:删除节点为c ,那么前驱节点为 m,后继节点为n
     *                                          a
     *                                       /     \
     *                                    b          c
     *                                  / \         /  \
     *                                d    e       f    g
     *                              /  \  / \     / \   / \
     * @param item 删除元素          h   i  j  k   l   m n   o
     * @return 删除结果
     */
    public boolean remove(T item){
        //获取删除节点
        Entry<T> delEntry = getEntry(item);
        if (delEntry == null) return false;
        //删除节点的父节点
        Entry<T> p = delEntry.parent;
        size--;
        //情况1:没有子节点
        if (delEntry.left == null && delEntry.right == null){
            //删除节点为根节点
            if (delEntry == root){
                root = null;
            }else {//非根节点
                //删除的是父节点的左节点
                if (delEntry == p.left){
                    p.left = null;
                }else {//删除右节点
                    p.right = null;
                }
            }
            //情况2:删除的节点只有左节点
        }else if (delEntry.right == null){
            Entry<T> lc = delEntry.left;
            //删除的节点为根节点,将删除节点的左节点设置成根节点
            if (p == null) {
                lc.parent = null;
                root = lc;
            } else {//非根节点
                if (delEntry == p.left){//删除左节点
                    p.left = lc;
                }else {//删除右节点
                    p.right = lc;
                }
                lc.parent = p;
            }
            //情况3:删除节点只有右节点
        }else if (delEntry.left == null){
            Entry<T> rc = delEntry.right;
            //删除根节点
            if (p == null) {
                rc.parent = null;
                root = rc;
            }else {//删除非根节点
                if (delEntry == p.left)
                    p.left = rc;
                else
                    p.right = rc;
                rc.parent = p;
            }
            //情况4:删除节点有两个子节点
        }else {//有两个节点,找到后继节点,将值赋给删除节点,然后将后继节点删除掉即可
            Entry<T> successor = successor(delEntry);//获取到后继节点
            delEntry.item = successor.item;
            //后继节点为右子节点
            if (delEntry.right == successor){
                //右子节点有右子节点
                if (successor.right != null) {
                    delEntry.right = successor.right;
                    successor.right.parent = delEntry;
                }else {//右子节点没有子节点
                    delEntry.right = null;
                }
            }else {//后继节点必定是左节点
                successor.parent.left = null;
            }
            return true;
        }
        //让gc回收
        delEntry.parent = null;
        delEntry.left = null;
        delEntry.right = null;
        return true;
    }

/**
     * 获取节点节点
     * @param item 获取节点
     * @return 获取到的节点,可能为null
     */
    private Entry<T> getEntry(T item){
        Entry<T> t = root;
        int ret;
        //从根节点开始遍历
        for (;t != null;){
            ret = item.compareTo(t.item);
            if (ret < 0)
                t = t.left;
            else if (ret > 0)
                t = t.right;
            else
                return t;
        }
        return null;
    }


    /**
     * 查找后继节点
     * @param delEntry 删除节点
     * @return 后继节点
     */
    private Entry<T> successor(Entry<T> delEntry) {
        Entry<T> r = delEntry.right;//r节点必定不为空
        while (r.left != null){
            r = r.left;
        }
        return r;
    }

   二叉树获取节点

    /**
     * 判断是否存在该元素
     * @param item 查找元素
     * @return 结果
     */
    public boolean contains(T item){
        return getEntry(item) != null;
    }


    
    /**
     * 获取节点节点
     * @param item 获取节点
     * @return 获取到的节点,可能为null
     */
    private Entry<T> getEntry(T item){
        Entry<T> t = root;
        int ret;
        //从根节点开始遍历
        for (;t != null;){
            ret = item.compareTo(t.item);
            if (ret < 0)
                t = t.left;
            else if (ret > 0)
                t = t.right;
            else
                return t;
        }
        return null;
    }

  因为我这个例子是存储一个元素,获取到的元素和传进去的元素是一致的,所以我用contains方法来判断返回true即表示获取成功了,不返回获取到的结果了。当然,如果将entry存储的元素改为kv形式的话,就可以使用get方法了。

 

  二叉树的遍历

  二叉树的遍历可以分为三种:前序遍历、中序遍历和后续遍历,其中中序遍历是最常用的遍历方式,因为它遍历出来的结果的升序的。

  前序遍历:

     /**
     * 前序遍历
     * @param e 开始遍历元素
     */
    public void prevIterator(Entry<T> e){
        if (e != null) {
            System.out.print(e.item + " ");
            prevIterator(e.left);
            prevIterator(e.right);
        }
    }

  中序遍历:

   /**
     * 中序遍历
     * @param e
     */
    public void midIterator(Entry<T> e){
        if (e != null){
            midIterator(e.left);
            System.out.print(e.item + " ");
            midIterator(e.right);
        }
    }

  后序遍历:

    /**
     * 后续遍历
     * @param e 开始遍历元素
     */
    public void subIterator(Entry<T> e){
        if (e != null) {
            subIterator(e.left);
            subIterator(e.right);
            System.out.print(e.item + " ");
        }
    }

 

  demo完整的代码:也可以到我的github中下载代码:https://github.com/rainple1860/MyCollection

package com.rainple.collections;

/**
 * 二叉树
 * @param <T>
 */
public class BinaryTree<T extends Comparable<T>> {

    //根节点
    private Entry<T> root;
    //数据量
    private int size = 0;

    public BinaryTree(){}

    /**
     * 添加元素
     * @param item 待添加元素
     * @return 已添加元素
     */
    public T put(T item){
        //每次添加数据的时候都是从根节点向下遍历
        Entry<T> t = root;
        size++;
        if (t == null){
            //当前的叉树树的为空,将新节点设置为根节点,父节点为null
            root = new Entry<>(item,null);
            return root.item;
        }
        //自然排序结果,如果传入的数据小于当前节点返回-1,大于当前节点返回1,否则返回0
        int ret = 0;
        //记录父节点
        Entry<T> p = t;
        while (t != null){
            //与当前节点比较
            ret = item.compareTo(t.item);
            p = t;
            //插入节点比当前节点小,把当前节点设置为左子节点,然后与左子比较,以此类推找到合适的位置
            if (ret < 0)
                t = t.left;
            //大于当前节点
            else if (ret > 0)
                t = t.right;
            else {
                //相等就把旧值覆盖掉
                t.item = item;
                return t.item;
            }
        }
        //创建新节点
        Entry<T> e = new Entry<>(item,p);
        //根据比较结果将新节点放入合适的位置
        if (ret < 0)
            p.left = e;
        else
            p.right = e;
        return e.item;
    }

    public void print(){
        midIterator(root);
    }

    /**
     * 中序遍历
     * @param e
     */
    public void midIterator(Entry<T> e){
        if (e != null){
            midIterator(e.left);
            System.out.print(e.item + " ");
            midIterator(e.right);
        }
    }

    /**
     * 获取根节点
     * @return 根节点
     */
    public Entry<T> getRoot(){return root;}

    /**
     * 前序遍历
     * @param e 开始遍历元素
     */
    public void prevIterator(Entry<T> e){
        if (e != null) {
            System.out.print(e.item + " ");
            prevIterator(e.left);
            prevIterator(e.right);
        }
    }

    /**
     * 后续遍历
     * @param e 开始遍历元素
     */
    public void subIterator(Entry<T> e){
        if (e != null) {
            subIterator(e.left);
            subIterator(e.right);
            System.out.print(e.item + " ");
        }
    }

    /**
     * 获取节点节点
     * @param item 获取节点
     * @return 获取到的节点,可能为null
     */
    private Entry<T> getEntry(T item){
        Entry<T> t = root;
        int ret;
        //从根节点开始遍历
        for (;t != null;){
            ret = item.compareTo(t.item);
            if (ret < 0)
                t = t.left;
            else if (ret > 0)
                t = t.right;
            else
                return t;
        }
        return null;
    }

    /**
     * 判断是否存在该元素
     * @param item 查找元素
     * @return 结果
     */
    public boolean contains(T item){
        return getEntry(item) != null;
    }

    /**
     * 删除元素
     * 删除元素如果细分的话,可以分为4中:没有子节点,只有左节点,只有右节点,有两个子节点
     * 1)没有子节点这种情况比较简单,直接删除就可以了
     * 2)只有左节点或右节点,这两种情况处理方式是一致的,只是方向相反,所以在一起讲了,
     * 将删除节点的父节点的左节点(右节点)指向删除节点的子节点,将左节点(右节点)指向删除节点的父节点
     * 3)有两个子节点,这种情况相对来说比较复杂一点:
     * 找到删除节点的前驱节点或后继节点,然后将前驱或后继节点的值赋给删除节点,然后将前驱或后继节点删除。本质是删除前驱或后继节点
     * 前驱节点的特点:
     * 1)删除的左子节点没有右子节点,那么左子节点即为前驱节点
     * 2)删除节点的左子节点有右子节点,那么最右边的最后一个节点即为前驱节点
     * 后继节点的特点:
     * 与前驱节点刚好相反,总是右子节点,或则右子节点的最左子节点;例如:删除节点为c ,那么前驱节点为 m,后继节点为n
     *                                          a
     *                                       /     \
     *                                    b          c
     *                                  / \         /  \
     *                                d    e       f    g
     *                              /  \  / \     / \   / \
     * @param item 删除元素       h   i  j  k   l   m n   o
     * @return 删除结果
     */
    public boolean remove(T item){
        //获取删除节点
        Entry<T> delEntry = getEntry(item);
        if (delEntry == null) return false;
        //删除节点的父节点
        Entry<T> p = delEntry.parent;
        size--;
        //情况1:没有子节点
        if (delEntry.left == null && delEntry.right == null){
            //删除节点为根节点
            if (delEntry == root){
                root = null;
            }else {//非根节点
                //删除的是父节点的左节点
                if (delEntry == p.left){
                    p.left = null;
                }else {//删除右节点
                    p.right = null;
                }
            }
            //情况2:删除的节点只有左节点
        }else if (delEntry.right == null){
            Entry<T> lc = delEntry.left;
            //删除的节点为根节点,将删除节点的左节点设置成根节点
            if (p == null) {
                lc.parent = null;
                root = lc;
            } else {//非根节点
                if (delEntry == p.left){//删除左节点
                    p.left = lc;
                }else {//删除右节点
                    p.right = lc;
                }
                lc.parent = p;
            }
            //情况3:删除节点只有右节点
        }else if (delEntry.left == null){
            Entry<T> rc = delEntry.right;
            //删除根节点
            if (p == null) {
                rc.parent = null;
                root = rc;
            }else {//删除非根节点
                if (delEntry == p.left)
                    p.left = rc;
                else
                    p.right = rc;
                rc.parent = p;
            }
            //情况4:删除节点有两个子节点
        }else {//有两个节点,找到后继节点,将值赋给删除节点,然后将后继节点删除掉即可
            Entry<T> successor = successor(delEntry);//获取到后继节点
            delEntry.item = successor.item;
            //后继节点为右子节点
            if (delEntry.right == successor){
                //右子节点有右子节点
                if (successor.right != null) {
                    delEntry.right = successor.right;
                    successor.right.parent = delEntry;
                }else {//右子节点没有子节点
                    delEntry.right = null;
                }
            }else {//后继节点必定是左节点
                successor.parent.left = null;
            }
            return true;
        }
        //让gc回收
        delEntry.parent = null;
        delEntry.left = null;
        delEntry.right = null;
        return true;
    }

    /**
     * 查找后继节点
     * @param delEntry 删除节点
     * @return 后继节点
     */
    private Entry<T> successor(Entry<T> delEntry) {
        Entry<T> r = delEntry.right;//r节点必定不为空
        while (r.left != null){
            r = r.left;
        }
        return r;
    }

    public int size(){return size;}

    public boolean isEmpty(){return size == 0;}

    public void clear(){
        clear(getRoot());
        root = null;
    }

    private void clear(Entry<T> e){
        if (e != null){
            clear(e.left);
            e.left = null;
            clear(e.right);
            e.right = null;
        }
    }

    static final class Entry<T extends Comparable<T>>{
        //保存的数据
        private T item;
        //左子树
        private Entry<T> left;
        //右子树
        private Entry<T> right;
        //父节点
        private Entry<T> parent;
        Entry(T item,Entry<T> parent){
            this.item = item;
            this.parent = parent;
        }
    }

}

   

  测试代码示例:

public static void main(String[] args) {
       BinaryTree<Integer> binaryTree = new BinaryTree<>();
        //放数据
        binaryTree.put(73);
        binaryTree.put(22);
        binaryTree.put(532);
        binaryTree.put(62);
        binaryTree.put(72);
        binaryTree.put(243);
        binaryTree.put(42);
        binaryTree.put(3);
        binaryTree.put(12);
        binaryTree.put(52);

        System.out.println("size: " + binaryTree.size());
        binaryTree.put(52);
        System.out.println("添加相同元素后的size: " + binaryTree.size());
        //判断数据是否存在
        System.out.println("数据是否存在:" + binaryTree.contains(12));
        //中序遍历
        System.out.print("中序遍历结果: ");
        binaryTree.midIterator(binaryTree.getRoot());
        System.out.println();
        //前序遍历
        System.out.print("前遍历结果: ");
        binaryTree.prevIterator(binaryTree.getRoot());
        System.out.println();
        //后序遍历
        System.out.print("后续遍历结果: ");
        binaryTree.subIterator(binaryTree.getRoot());
        //删除数据
        System.out.println();
        binaryTree.remove(62);
        System.out.println("删除数据后判断是否存在:" + binaryTree.contains(62));
        //清空二叉树
        binaryTree.clear();
        System.out.print("清空数据后中序遍历: ");
        binaryTree.midIterator(binaryTree.getRoot());
    }

  测试结果:

size: 10
添加相同元素后的size: 10
数据是否存在:true
中序遍历结果: 3 12 22 42 52 62 72 73 243 532 
前遍历结果: 73 22 3 12 62 42 52 72 532 243 
后续遍历结果: 12 3 52 42 72 62 22 243 532 73 
删除数据后判断是否存在:false
清空数据后中序遍历: 

  纯手写的demo,有什么错误的地方欢迎指正,谢谢大家的阅读!!!

原文地址:http://www.manongjc.com/article/19267.html