Java-数据结构之二叉树练习
本来这个随笔应该在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-数据结构之二叉树练习的更多相关文章
- java数据结构之二叉树的实现
java二叉树的简单实现,可以简单实现深度为n的二叉树的建立,二叉树的前序遍历,中序遍历,后序遍历输出. /** *数据结构之树的实现 *2016/4/29 * **/ package cn.Link ...
- Java数据结构之二叉树的基本介绍与递归遍历
二叉树的基本概念: 正如我们所了解的,树是有很多中形态,但是我们规定,形如每个节点最多只能有两个子节点的一种形如称为二叉树.我们将二叉树中该节点的两个子节点分别称作为:左孩子节点和右孩子节点.该节点称 ...
- JAVA数据结构之二叉树
用树作为存储数据的结构兼具像数组一样查询速度快和像链表一样具有很快的插入和删除数据项的优点 我们用圆点表示节点,连接圆的直线表示边如下图所示就表示了一颗树,接下来我们讨论的二叉树即每个节点最多只有两个 ...
- java数据结构之二叉树遍历的非递归实现
算法概述递归算法简洁明了.可读性好,但与非递归算法相比要消耗更多的时间和存储空间.为提高效率,我们可采用一种非递归的二叉树遍历算法.非递归的实现要借助栈来实现,因为堆栈的先进后出的结构和递归很相似.对 ...
- java数据结构之二叉树的定义和递归实现
定义最多有两棵子树的有序树,称为二叉树.二叉树是一种特殊的树.递归定义:二叉树是n(n>=0)个有限结点构成的集合.N=0称为空二叉树:n>0的二叉树由一个根结点和两互不相交的,分别称为左 ...
- Java数据结构之树和二叉树(2)
从这里始将要继续进行Java数据结构的相关讲解,Are you ready?Let's go~~ Java中的数据结构模型可以分为一下几部分: 1.线性结构 2.树形结构 3.图形或者网状结构 接下来 ...
- Java数据结构之树和二叉树
从这里开始将要进行Java数据结构的相关讲解,Are you ready?Let's go~~ Java中的数据结构模型可以分为一下几部分: 1.线性结构 2.树形结构 3.图形或者网状结构 接下来的 ...
- Java数据结构和算法 - 二叉树
前言 数据结构可划分为线性结构.树型结构和图型结构三大类.前面几篇讨论了数组.栈和队列.链表都是线性结构.树型结构中每个结点只允许有一个直接前驱结点,但允许有一个以上直接后驱结点.树型结构有树和二叉树 ...
- Java数据结构和算法(六)--二叉树
什么是树? 上面图例就是一个树,用圆代表节点,连接圆的直线代表边.树的顶端总有一个节点,通过它连接第二层的节点,然后第二层连向更下一层的节点,以此递推 ,所以树的顶端小,底部大.和现实中的树是相反的, ...
- 【java 数据结构】还不会二叉树?一篇搞定二叉树
二叉树是我们常见的数据结构之一,在学习二叉树之前我们需要知道什么是树,什么是二叉树,本篇主要讲述了二叉树,以及二叉树的遍历. 你能get到的知识点? 1.树的介绍 2.二叉树的介绍 3.二叉树遍历的四 ...
随机推荐
- ZIP文件压缩和解压
最近要做一个文件交互,上传和下载, 都是zip压缩文件,所以研究了下,写了如下的示例 注意引用 ICSharpCode.SharpZipLib.dll 文件 该dll文件可以到官方网站去下载, 我这 ...
- [总结]SHAREPOINT - CAML列表查询(上)
首先要了解的是CAML(Collaboration Application Markup Language)不仅仅是用在对列表.文档库的查询,字段的定义,站点定义等处处使用的都是CAML. 简单的提一 ...
- SQL查询某一字段重复的数据
查询出重复记录 select * from 数据表 WHERE 重复记录字段 in ( select 重复记录字段 from 数据表 group by 重复记录字段 having count(重复记 ...
- Python ssh连接Linux服务器报Incompatible ssh peer (no acceptable kex algorithm) 解决方法
python通过ssh连接linux服务器,部分服务器出现如下异常 03:50:48.725 FAIL ftp operation failed, Incompatible ssh peer (no ...
- Linux文件属性与权限
一.在Linux里面,任何一个文件都具有“User,Group,Others”(用户.用户组.其他人)三种身份 二.用户组最有用的功能之一,就是当你在团队开发资源的时候,且每个账号都可以有多个用户组的 ...
- npm升级自身
参考:https://github.com/felixrieseberg/npm-windows-upgrade Usage First, ensure that you can execute sc ...
- 在西雅图华盛顿大学 (University of Washington) 就读是怎样一番体验?
http://www.zhihu.com/question/20811431 先说学校.优点: 如果你是个文青/装逼犯,你来对地方了.连绵不断的雨水会一下子让写诗的感觉将你充满. 美丽的校园.尤其 ...
- PHP APC安装与使用
先要解决一下httpd-devel依赖库问题 yum install cyrus-sasl-devel db4-devel openldap apr apr-util apr-util-devel p ...
- 2018.8.1 Java中的反射和同步详解
为何要使用同步? java允许多线程并发控制,当多个线程同时操作一个可共享的资源变量时(如数据的增删改查), 将会导致数据不准确,相互之间产生冲突,因此加入同步锁以避免在该线程没有完成操作之前,被其他 ...
- tree树形
/** * tree * @param menuBeans * @param pid * @return */ public JSON makeTree(List<MenuBean& ...