Java-数据结构之二叉树练习

本来这个随笔应该在4月17号就应该发出来的。不巧的是，那天晚上收到了offer，然后接下去两天为入职到处跑，20号入职后一直忙，直到最近几天才有时间看看书。然而20多天前就看完的了二叉树，然后17号那天正在按照二叉树的定义自己写一个完整的二叉树。本来那天晚上就能完成的，这么一个打断，导致现在想接上去之前的思路继续写二叉树有点难了。所以二叉树里面的删除部分以及Iterator部分直接是看着书写的......

下面是MyBinaryTree.java

//MyBinaryTree.javapackage struct;

import java.util.ArrayList;
import java.util.Iterator;

public class MyBinaryTree<E extends Comparable<E>>
{
    private TreeNode<E> root;
    private int treeSize=0;

    public MyBinaryTree()
    {}

    public MyBinaryTree(E[] o)
    {
        for(int i=0;i<o.length;i++)
        {
            insert(o[i]);
        }
    } 

    private class TreeNode<E extends Comparable<E>>
    {
        public E element;
        public TreeNode<E> leftChild;
        public TreeNode<E> rightChild;

        public TreeNode()
        {}

        public TreeNode(E o)
        {
            this.element = o;
        }
    }

    //寻找一个元素
    public boolean search(E o)
    {
        TreeNode<E> current;

        if(root == null)
            return false;
        else
        {
            current=root;

            while(true)
            {
                if(current.element.compareTo(o) == 0) //相等
                {
                    return true;
                }
                else if(current.element.compareTo(o) > 0)  //current.element大
                {
                    if(current.leftChild!=null) current = current.leftChild;
                    else
                        return false;
                }
                else if(current.element.compareTo(o) < 0)  //o大
                {
                    if(current.rightChild!=null) current = current.rightChild;
                    else
                        return false;
                }
                else
                    return false;
            }
        }
    }

    //插入一个元素
    public boolean insert(E o)
    {
        TreeNode<E> current;

        if(root==null)
        {
            root = new TreeNode<E>(o);
            treeSize++;
            return true;
        }
        else
        {
            current=root;

            while(true)
            {
                if(current.element.compareTo(o) > 0) //current.element大
                {
                    if(current.leftChild!=null) current = current.leftChild;
                    else
                    {
                        current.leftChild = new TreeNode<E>(o);
                        treeSize++;
                        return true;
                    }
                }
                else if(current.element.compareTo(o) < 0)    //o大
                {
                    if(current.rightChild!=null) current = current.rightChild;
                    else
                    {
                        current.rightChild = new TreeNode<E>(o);
                        treeSize++;
                        return true;
                    }
                }
                else
                {
                    return false;
                }
            }
        }
    }

    //删除一个元素
    public boolean delete(E o)
    {
        TreeNode<E> current=root;
        TreeNode<E> parent=null;

        //current==root==null返回false
        if(current==null)
            return false;
        //寻找一个相等的元素
        while(current.element.compareTo(o)!=0)
        {
            if(current.element.compareTo(o) > 0)
            {
                if(current.leftChild == null)
                    return false;
                else
                {
                    parent = current;
                    current = current.leftChild;
                }
            }
            else
            {
                if(current.rightChild == null)
                    return false;
                else
                {
                    parent = current;
                    current = current.rightChild;
                }
            }
        }

        //找到一个相等的元素之后,左右子树均为空
        if(current.leftChild==null && current.rightChild==null)
        {
            current = null;
            treeSize--;
            return true;
        }
        else if(current.leftChild==null)//左子树为空
        {
            if(parent==null)
                root=current.rightChild;
            else
            {
                if(parent.element.compareTo(o)>0)
                    parent.leftChild=current.rightChild;
                else
                    parent.rightChild=current.rightChild;
            }
            treeSize--;
            return true;
        }
        else
        {
            //右子树为空，或者左右子树均不为空
            TreeNode<E> parentOfBiggest = current;
            TreeNode<E> theBiggest = current.leftChild;

            while(theBiggest.rightChild!=null)
            {
                parentOfBiggest=theBiggest;
                theBiggest = theBiggest.rightChild;
            }

            current.element = theBiggest.element;

            if(parentOfBiggest.rightChild == theBiggest)
                parentOfBiggest.rightChild = theBiggest.leftChild;
            else
                parentOfBiggest.leftChild = theBiggest.leftChild;

            treeSize--;
            return true;
        }
    }

    //中序
    public void inorder()
    {
        TreeNode<E> current;
        current = root;
        if(current!=null)
        {
            inorder(current.leftChild);
            System.out.print(current.element+" ");
            inorder(current.rightChild);
            System.out.println();
        }
    }

    private void inorder(TreeNode<E> current)
    {
        if(current!=null)
        {
            inorder(current.leftChild);
            System.out.print(current.element+" ");
            inorder(current.rightChild);
        }
    }

    //前序
    public void preorder()
    {
        TreeNode<E> current;
        current = root;
        if(current!=null)
        {
            System.out.print(current.element+" ");
            preorder(current.leftChild);
            preorder(current.rightChild);
            System.out.println();
        }
    }

    private void preorder(TreeNode<E> current)
    {
        if(current!=null)
        {
            System.out.print(current.element+" ");
            preorder(current.leftChild);
            preorder(current.rightChild);
        }
    }

    //后序
    public void postorder()
    {
        TreeNode<E> current;
        current = root;
        if(current!=null)
        {
            postorder(current.leftChild);
            postorder(current.rightChild);
            System.out.print(current.element+" ");
            System.out.println();
        }
    }

    private void postorder(TreeNode<E> current)
    {
        if(current!=null)
        {
            postorder(current.leftChild);
            postorder(current.rightChild);
            System.out.print(current.element+" ");
        }
    }

    //get树的大小
    public int getSize()
    {
        return treeSize;
    }

    //是否为空
    public boolean isEmpty()
    {
        return treeSize==0;
    }

    //iterator
    public Iterator iterator()
    {
        return inorderIterator();
    }

    //清空
    public void clear()
    {
        root=null;
        treeSize=0;
    }

    public Iterator inorderIterator()
    {
        return new InorderIterator();
    }

    class InorderIterator implements Iterator
    {
        private ArrayList<E> list = new ArrayList<E>();
        private int current = 0;

        public InorderIterator()
        {
            inorder();
        }

        private void inorder()
        {
            inorder(root);
        }

        private void inorder(TreeNode<E> root)
        {
            if(null == root)
                return;
            inorder(root.leftChild);
            list.add(root.element);
            inorder(root.rightChild);
        }

        @Override
        public boolean hasNext()
        {
            if(current < list.size())
                return true;

            return false;
        }

        @Override
        public Object next()
        {
            return list.get(current++);
        }

        public void remove()
        {
            delete(list.get(current));
            list.clear();
            inorder();
        }
    }
}

下面是MyBinaryTreeTest.java

//MyBinaryTreeTest.javapackage struct;

public class MyBinaryTreeTest
{
    public static void main(String[] args)
    {
        MyBinaryTree<Integer> mbt = new MyBinaryTree<Integer>();
        mbt.insert(12);
        mbt.insert(34);
        mbt.insert(6);
        mbt.insert(24);
        mbt.insert(4);
        mbt.insert(346);
        mbt.insert(40);
        mbt.insert(346);

        System.out.println("mbt size: "+mbt.getSize());

        if(!mbt.search(346))
            System.out.println("did not contains!");
        else
            System.out.println("have this number!");

        System.out.print("mbt inorder: ");
        mbt.inorder();
        System.out.print("mbt preorder: ");
        mbt.preorder();
        System.out.print("mbt postorder: ");
        mbt.postorder();

        Integer[] a = new Integer[]{56,26,24,89,1,100,7,55,43,1};
        MyBinaryTree<Integer> mbt2 = new MyBinaryTree<Integer>(a);

        System.out.print("mbt2 inorder: ");
        mbt2.inorder();
        System.out.print("mbt2 preorder: ");
        mbt2.preorder();
        System.out.print("mbt2 postorder: ");
        mbt2.postorder();

        System.out.println("mbt2 size: "+mbt2.getSize());
        mbt2.clear();
        System.out.println("mbt2 size: "+mbt2.getSize());

        if(!mbt2.search(1))
            System.out.println("did not contains!");
        else
            System.out.println("have this number!");

        MyBinaryTree<Integer> mbt3 = new MyBinaryTree<Integer>(a);
        System.out.print("mbt3 inorder: ");
        mbt3.inorder();
        System.out.print("mbt3 preorder: ");
        mbt3.preorder();
        System.out.print("mbt3 postorder: ");
        mbt3.postorder();

        System.out.println("before delete size:"+mbt3.getSize());
        System.out.println(mbt3.delete(26));
        System.out.println("after delete size:"+mbt3.getSize());
        System.out.print("mbt3 inorder: ");
        mbt3.inorder();
        System.out.print("mbt3 preorder: ");
        mbt3.preorder();
        System.out.print("mbt3 postorder: ");
        mbt3.postorder();

        System.out.println("before delete size:"+mbt3.getSize());
        System.out.println(mbt3.delete(1888));
        System.out.println("after delete size:"+mbt3.getSize());
    }
}

最后是运行结果

//resultmbt size: 7
have this number!
mbt inorder: 4 6 12 24 34 40 346
mbt preorder: 12 6 4 34 24 346 40
mbt postorder: 4 6 24 40 346 34 12
mbt2 inorder: 1 7 24 26 43 55 56 89 100
mbt2 preorder: 56 26 24 1 7 55 43 89 100
mbt2 postorder: 7 1 24 43 55 26 100 89 56
mbt2 size: 9
mbt2 size: 0
did not contains!
mbt3 inorder: 1 7 24 26 43 55 56 89 100
mbt3 preorder: 56 26 24 1 7 55 43 89 100
mbt3 postorder: 7 1 24 43 55 26 100 89 56
before delete size:9
true
after delete size:8
mbt3 inorder: 1 7 24 43 55 56 89 100
mbt3 preorder: 56 24 1 7 55 43 89 100
mbt3 postorder: 7 1 43 55 24 100 89 56
before delete size:8
false
after delete size:8
时间： 2025-01-13 22:41:52

Java-数据结构之二叉树练习的相关文章

java数据结构：二叉树

树:树形结构的特点是一个节点可有多个直接后继,是一种常用的非线性结构. 二叉树:结合了有序数组和链表的优点,在树中查找数据和在有序数组中查找一样快,增删数据和在链表中一样快. 插入操作时,二叉树从根节点开始,比父节点大的往左边插入,比父节点小的往右边插入 下面是链表实现二叉树: Node.java package BTree; /** * 链表二叉树的节点类 */ public class Node { int data; Node leftChild; Node rightChild; //初

java数据结构之二叉树遍历的非递归实现

算法概述递归算法简洁明了.可读性好,但与非递归算法相比要消耗更多的时间和存储空间.为提高效率,我们可采用一种非递归的二叉树遍历算法.非递归的实现要借助栈来实现,因为堆栈的先进后出的结构和递归很相似.对于中序遍历来说,非递归的算法比递归算法的效率要高的多.其中序遍历算法的实现的过程如下:(1).初始化栈,根结点进栈:(2).若栈非空,则栈顶结点的左孩子结点相继进栈,直到null(到叶子结点时)退栈:访问栈顶结点(执行visit操作)并使栈顶结点的右孩子结点进栈成为栈顶结点.(3).重复执行(2),

java数据结构与算法之树基本概念及二叉树（BinaryTree）的设计与实现

[版权申明]未经博主同意,不允许转载!(请尊重原创,博主保留追究权) http://blog.csdn.net/javazejian/article/details/53727333 出自[zejian的博客] 关联文章: java数据结构与算法之顺序表与链表设计与实现分析 java数据结构与算法之双链表设计与实现 java数据结构与算法之改良顺序表与双链表类似ArrayList和LinkedList(带Iterator迭代器与fast-fail机制) java数据结构与算法之栈(Stack)设

【数据结构】二叉树的java实现

二叉树概述 数组.向量.链表都是一种顺序容器,它们提供了按位置访问数据的手段.而很多情况下,我们需要按数据的值来访问元素,而不是它们的位置来访问元素.比如有这样一个数组int num[3]={1,2,3},我们可以非常快速的访问数组中下标为2的数据,也就是说我们知道这个数据的位置,就可以快速访问.有时候我们是不知道元素的位置,但是却知道它的值是多少.假设我们有一个变量,存放在num这个数组中,我们知道它的值为2,却不知道它下标是多少,也就是说不知道它的位置.这个时候再去数组中访问这个元素就比较费

Java数据结构系列之——树（4）：二叉树的中序遍历的递归与非递归实现

package tree.binarytree; import java.util.Stack; /** * 二叉树的中序遍历:递归与非递归实现 * * @author wl * */ public class BiTreeInOrder { // 中序遍历的递归实现 public static void biTreeInOrderByRecursion(BiTreeNode root) { if (root == null) { return; } biTreeInOrderByRecursi

Java数据结构系列之——树（5）：二叉树的后序遍历的递归与非递归实现

package tree.binarytree; import java.util.Stack; /** * 二叉树后序遍历的递归与非递归实现 * * @author wl * */ public class BitreePostOrder { // 后序遍历的递归实现 public static void biTreePostOrderByRecursion(BiTreeNode root) { if (root == null) { return; } biTreePostOrderByRe

【数据结构】二叉树的Java实践

二叉树,是常用的树之一. 性质: 每个节点最多有2个节点(即度最大为2) 有左.右节点(或左.右子树)之分,且节点有顺序之分(即左.右不能随意调换) 下面对二叉树做最简单的Java实践. > 二叉树的Java实践 树节点 package com.nicchagil.btree; public class TreeNode { private Integer value; private TreeNode left; private TreeNode right; public TreeNode(

Java数据结构之树和二叉树

从这里开始将要进行Java数据结构的相关讲解,Are you ready?Let's go~~ Java中的数据结构模型可以分为一下几部分: 1.线性结构 2.树形结构 3.图形或者网状结构 接下来的几章,我们将会分别讲解这几种数据结构,主要也是通过Java代码的方式来讲解相应的数据结构. 今天要讲解的是:Java线性结构 Java数据结构之树形结构 之前我们前几章学习的都是Java数据结构的线性结构,都是一对一的,从现在开始我们将要学习Java的树形结构. 树对于我们来普通Java程序员而言,

Java数据结构之二叉搜索树

Java数据结构之二叉搜索树 1.二叉搜索树组成 二叉搜索树又称为二叉排序树,它或者是一颗空树,或者是一颗具有如下特性的非空二叉树,需要满足一下三个条件: (1)若它的左子树非空,则左子树上所有结点的关键字均小于根结点的关键字: (2)若它的右子树非空,则右子树上所有结点的关键字均大于(可以等于)根结点的关键字. (3)左子树右子树本身又各是一颗二叉搜索树 在算法描述中,均以结点值的比较来代表其关键字的比较,因为若结点的值为类类型时,该类必须实现系统提供的java.lang.comparable

java数据结构与算法之顺序表与链表深入分析

转载请注明出处(万分感谢!): http://blog.csdn.net/javazejian/article/details/52953190 出自[zejian的博客] 关联文章: java数据结构与算法之顺序表与链表设计与实现分析 java数据结构与算法之双链表设计与实现 ??数据结构与算法这门学科虽然在大学期间就已学习过了,但是到现在确实也忘了不少,因此最近又重新看了本书-<数据结构与算法分析>加上之前看的<java数据结构>也算是对数据结构的进一步深入学习了,于是也就打算