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

下面是MyBinaryTree.java

//MyBinaryTree.java
package 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.java
package 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());
}
}

最后是运行结果

//result
mbt 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

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

  1. java数据结构之二叉树的实现

    java二叉树的简单实现,可以简单实现深度为n的二叉树的建立,二叉树的前序遍历,中序遍历,后序遍历输出. /** *数据结构之树的实现 *2016/4/29 * **/ package cn.Link ...

  2. Java数据结构之二叉树的基本介绍与递归遍历

    二叉树的基本概念: 正如我们所了解的,树是有很多中形态,但是我们规定,形如每个节点最多只能有两个子节点的一种形如称为二叉树.我们将二叉树中该节点的两个子节点分别称作为:左孩子节点和右孩子节点.该节点称 ...

  3. JAVA数据结构之二叉树

    用树作为存储数据的结构兼具像数组一样查询速度快和像链表一样具有很快的插入和删除数据项的优点 我们用圆点表示节点,连接圆的直线表示边如下图所示就表示了一颗树,接下来我们讨论的二叉树即每个节点最多只有两个 ...

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

    算法概述递归算法简洁明了.可读性好,但与非递归算法相比要消耗更多的时间和存储空间.为提高效率,我们可采用一种非递归的二叉树遍历算法.非递归的实现要借助栈来实现,因为堆栈的先进后出的结构和递归很相似.对 ...

  5. java数据结构之二叉树的定义和递归实现

    定义最多有两棵子树的有序树,称为二叉树.二叉树是一种特殊的树.递归定义:二叉树是n(n>=0)个有限结点构成的集合.N=0称为空二叉树:n>0的二叉树由一个根结点和两互不相交的,分别称为左 ...

  6. Java数据结构之树和二叉树(2)

    从这里始将要继续进行Java数据结构的相关讲解,Are you ready?Let's go~~ Java中的数据结构模型可以分为一下几部分: 1.线性结构 2.树形结构 3.图形或者网状结构 接下来 ...

  7. Java数据结构之树和二叉树

    从这里开始将要进行Java数据结构的相关讲解,Are you ready?Let's go~~ Java中的数据结构模型可以分为一下几部分: 1.线性结构 2.树形结构 3.图形或者网状结构 接下来的 ...

  8. Java数据结构和算法 - 二叉树

    前言 数据结构可划分为线性结构.树型结构和图型结构三大类.前面几篇讨论了数组.栈和队列.链表都是线性结构.树型结构中每个结点只允许有一个直接前驱结点,但允许有一个以上直接后驱结点.树型结构有树和二叉树 ...

  9. Java数据结构和算法(六)--二叉树

    什么是树? 上面图例就是一个树,用圆代表节点,连接圆的直线代表边.树的顶端总有一个节点,通过它连接第二层的节点,然后第二层连向更下一层的节点,以此递推 ,所以树的顶端小,底部大.和现实中的树是相反的, ...

  10. 【java 数据结构】还不会二叉树?一篇搞定二叉树

    二叉树是我们常见的数据结构之一,在学习二叉树之前我们需要知道什么是树,什么是二叉树,本篇主要讲述了二叉树,以及二叉树的遍历. 你能get到的知识点? 1.树的介绍 2.二叉树的介绍 3.二叉树遍历的四 ...

随机推荐

  1. SQL查询某一字段重复的数据

    查询出重复记录 select * from 数据表 WHERE 重复记录字段 in ( select 重复记录字段 from  数据表 group by 重复记录字段 having count(重复记 ...

  2. *459. Repeated Substring Pattern (O(n^2)) two pointers could be better?

    Given a non-empty string check if it can be constructed by taking a substring of it and appending mu ...

  3. POJ-1990 MooFest---两个树状数组

    题目链接: https://vjudge.net/problem/POJ-1990 题目大意: 一群牛参加完牛的节日后都有了不同程度的耳聋,第i头牛听见别人的讲话,别人的音量必须大于v[i],当两头牛 ...

  4. 既然红黑树那么好,为啥hashmap不直接采用红黑树,而是当大于8个的时候才转换红黑树?

    因为红黑树需要进行左旋,右旋操作, 而单链表不需要,以下都是单链表与红黑树结构对比.如果元素小于8个,查询成本高,新增成本低如果元素大于8个,查询成本低,新增成本高 https://bbs.csdn. ...

  5. Treap 实现名次树

    在主流STL版本中,set,map,都是BST实现的,具体来说是一种称为红黑树的动态平衡BST: 但是在竞赛中并不常用,因为红黑树过于复杂,他的插入 5 种,删除 6 中,代码量极大(如果你要改板子的 ...

  6. BestCoder Round #91 1002 Lotus and Horticulture

    题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=6012 题意: 这几天Lotus对培养盆栽很感兴趣,于是她想搭建一个温室来满足她的研究欲望. Lotus ...

  7. 在vue中同时使用过渡和动画

    在上次的动画中,在显示和隐藏有动画效果,但是,刷新页面的时候,第一次的显示没有动画效果 需求:刷新页面的时候也有动画效果 <transition name='fade' appear enter ...

  8. django生命周期示意图

    1.图示

  9. vue 用户输入搜索 与无限下拉

    vue项目中,用户输入关键字搜索,并且手机端做无限下拉 watch: { 'getListForm.searchKey'(val) { this.radioChange(); // 还有其他逻辑,内部 ...

  10. 转:mysql远程连接 Host * is not allowed to connect to this MySQL server

    在本机登入mysql后,更改"mysql"数据库里的"user"表里的"host"项,从"localhost"改为'%' ...