转:http://blog.csdn.net/a19881029/article/details/24379339

实现代码:

 Node.java
 //节点类
public class Node{
int data;
Node left;
Node right;
public Node(int data){
this.data = data;
left = null;
right = null;
}
}
 
 BinarySearchTree.java
 
 public class BinarySearchTree {
//声明
public static  Node root;
public BinarySearchTree(){
this.root = null;
}
//Nod对象current为空=root
public boolean find(int id){
Node current = root;
while(current!=null){
if(current.data==id){
return true;
}else if(current.data>id){
current = current.left;
}else{
current = current.right;
}
}
return false;
}
//
public boolean delete(int id){
if(root == null)
return false;
else{
Node parent = root;
Node current = root;
boolean isLeftChild = false;
while(current.data!=id){
parent = current;
if(current.data>id){
isLeftChild = true;
current = current.left;
}else{
isLeftChild = false;
current = current.right;
}
if(current ==null){
return false;
}
}
//if i am here that means we have found the node
//Case 1: if node to be deleted has no children
if(current.left==null && current.right==null){
if(current==root){
root = null;
}
if(isLeftChild ==true){
parent.left = null;
}else{
parent.right = null;
}
}
//Case 2 : if node to be deleted has only one child
else if(current.right==null){
if(current==root){
root = current.left;
}else if(isLeftChild){
parent.left = current.left;
}else{
parent.right = current.left;
}
}
else if(current.left==null){
if(current==root){
root = current.right;
}else if(isLeftChild){
parent.left = current.right;
}else{
parent.right = current.right;
}
}else if(current.left!=null && current.right!=null){

//now we have found the minimum element in the right sub tree
Node successor  = getSuccessor(current);
if(current==root){
root = successor;
}else if(isLeftChild){
parent.left = successor;
}else{
parent.right = successor;
}
successor.left = current.left;
}
return true;
}
}
//
public Node getSuccessor(Node deleleNode){
Node successsor =null;
Node successsorParent =null;
//200,300,400
Node current = deleleNode.right;
while(current!=null){
successsorParent = successsor;
successsor = current;
current = current.left;
}
//check if successor has the right child, it cannot have left child for sure
// if it does have the right child, add it to the left of successorParent.
// successsorParent
if(successsor!=deleleNode.right){
successsorParent.left = successsor.right;
successsor.right = deleleNode.right;
}
return successsor;
}
//插入节点
public void insert(int id){
Node newNode = new Node(id);
if(root==null){
root = newNode;
return;
}
//current=100,200,300
Node current = root;
Node parent = null;
while(true){
parent = current;
if(id<current.data){
current = current.left;
if(current==null){
parent.left = newNode;
return;
}
}else{
current = current.right;
if(current==null){
parent.right = newNode;
return;
}
}
}
}

public void display(Node root, StringBuilder sb){
if(root!=null){
display(root.left, sb);
sb.append(" " + root.data);
display(root.right, sb);
}
}

public String inorderTraverse(Node root){
StringBuilder sb = new StringBuilder(); 
this.display(root, sb);
return sb.toString();
}
}

本人做的测试代码:
BranchSearchTreeTest1.java:

import static org.junit.Assert.*;

import org.junit.Test;

public class BinarySearchTreeTest1 {

BinarySearchTree bs1;
BinarySearchTree bs2;
BinarySearchTree bs3;
BinarySearchTree bs4;

@Test
public void testBinarySearchTree() {
}

@Test
public void testFind() {
bs1=new BinarySearchTree();
bs1.root=new Node(20);
bs1.root.left=new Node(10);
bs1.root.right=new Node(30);

//查找成功
assertTrue(bs1.find(20));
assertTrue(bs1.find(10));
assertTrue(bs1.find(30));
//查找失败
assertFalse(bs1.find(40));
}

@Test
public void testDelete() {
//root=null
bs1=new BinarySearchTree();
bs1.root=null;
assertFalse(bs1.delete(10));

//root!=null
bs2=new BinarySearchTree();
bs2.root=new Node(200);
bs2.root.left=new Node(100);
bs2.root.right=new Node(300);

assertTrue(bs2.delete(200));
assertFalse(bs2.delete(90));
assertFalse(bs2.delete(320));
assertTrue(bs2.delete(100));
assertTrue(bs2.delete(300));
}

@Test
public void testGetSuccessor() {
bs1=new BinarySearchTree();
Node n1=new Node(200);
n1.left=new Node(100);
n1.right=new Node(300);
n1.left.left=new Node(10);
n1.left.right=new Node(100);
n1.right.left=new Node(200);
n1.right.right=new Node(400);
assertEquals(200,bs1.getSuccessor(n1));

// bs2=new BinarySearchTree();
// Node n2=new Node(200);
// n2.left=new Node(100);
// n2.right=new Node(300);
// assertEquals(null,bs1.getSuccessor(n2));
}

@Test
public void testInsert() {
bs1=new BinarySearchTree();
//root=null,则newNode=root=10=current,parant=null
bs1.insert(10);

bs2=new BinarySearchTree();
bs2.root=new Node(200);
bs2.root.left=new Node(100);
bs2.root.right=new Node(300);
bs2.insert(100);
bs2.insert(300);

bs3=new BinarySearchTree();
bs3.root=new Node(200);
// bs3.root.left=new Node(100);
bs3.root.right=new Node(300);
bs3.insert(100);

// bs4=new BinarySearchTree();
// bs4.root=new Node(2000);
// bs4.root.left=new Node(1000);
//// bs4.root.right=new Node(300);
// bs4.insert(30000);
}

@Test
public void testDisplay() {
bs1=new BinarySearchTree();
bs1.display(bs1.root, null);

bs2=new BinarySearchTree();
bs2.root=new Node(20);
bs2.display(bs2.root, new StringBuilder());
}

@Test
public void testInorderTraverse() {
bs1=new BinarySearchTree();
bs1.inorderTraverse(null);

bs2=new BinarySearchTree();
bs2.root=new Node(20);
bs2.inorderTraverse(bs2.root);

}

}

测试结果:

二叉搜索树(Binary Search Tree)实现及测试的更多相关文章

  1. 编程算法 - 二叉搜索树(binary search tree) 代码(C)

    二叉搜索树(binary search tree) 代码(C) 本文地址: http://blog.csdn.net/caroline_wendy 二叉搜索树(binary search tree)能 ...

  2. 数据结构 《5》----二叉搜索树 ( Binary Search Tree )

    二叉树的一个重要应用就是查找. 二叉搜索树 满足如下的性质: 左子树的关键字 < 节点的关键字 < 右子树的关键字 1. Find(x) 有了上述的性质后,我们就可以像二分查找那样查找给定 ...

  3. [Data Structure] 二叉搜索树(Binary Search Tree) - 笔记

    1. 二叉搜索树,可以用作字典,或者优先队列. 2. 根节点 root 是树结构里面唯一一个其父节点为空的节点. 3. 二叉树搜索树的属性: 假设 x 是二叉搜索树的一个节点.如果 y 是 x 左子树 ...

  4. 二叉搜索树(Binary Search Tree)(Java实现)

    @ 目录 1.二叉搜索树 1.1. 基本概念 1.2.树的节点(BinaryNode) 1.3.构造器和成员变量 1.3.公共方法(public method) 1.4.比较函数 1.5.contai ...

  5. 二叉搜索树 (BST) 的创建以及遍历

    二叉搜索树(Binary Search Tree) : 属于二叉树,其中每个节点都含有一个可以比较的键(如需要可以在键上关联值), 且每个节点的键都大于其左子树中的任意节点而小于右子树的任意节点的键. ...

  6. [LeetCode] Split BST 分割二叉搜索树

    Given a Binary Search Tree (BST) with root node root, and a target value V, split the tree into two ...

  7. 自己动手实现java数据结构(六)二叉搜索树

    1.二叉搜索树介绍 前面我们已经介绍过了向量和链表.有序向量可以以二分查找的方式高效的查找特定元素,而缺点是插入删除的效率较低(需要整体移动内部元素):链表的优点在于插入,删除元素时效率较高,但由于不 ...

  8. BinarySearchTree二叉搜索树的实现

    /* 二叉搜索树(Binary Search Tree),(又:二叉查找树,二叉排序树)它或者是一棵空树,或者是具有下列性质的二叉树: 若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值; ...

  9. 二叉搜索树(BST)---python实现

    github:代码实现 本文算法均使用python3实现 1. 二叉搜索树定义   二叉搜索树(Binary Search Tree),又名二叉排序树(Binary Sort Tree).   二叉搜 ...

随机推荐

  1. spring cloud(服务注册中心及服务提供者——初学一)

    Eureka是Netflix开源的一款提供服务注册和发现的产品,它提供了完整的Service Registry和Service Discovery实现.也是springcloud体系中最重要最核心的组 ...

  2. Spring Boot打包war jar 部署tomcat

    概述 1.Spring Boot聚合工程打包war部署Tomcat 2.Spring Boot打包Jar,通过Java -jar直接运行. 3.提供完整pom.xml测试项目 至github 4.项目 ...

  3. c# winform as3相互调用

    C#主要代码: 首先要添加COM组件-Shockwave Flash Object //接收flash发送过来的信息        private void axShockwaveFlash1_Fla ...

  4. Android性能测试--垃圾回收频次统计的作用

    频繁的垃圾回收有可能暗示着内存泄露,在我手机统计数据,每次垃圾回收会占据100ms左右,这对内存和事件响应要求严格的程序(游戏等)来讲是可观的性能损耗.

  5. SOA,Webservice,SOAP,REST,RPC,RMI的区别与联系

    SOA,Webservice,SOAP,REST,RPC,RMI的区别与联系 SOA面向服务的软件架构(Service Oriented Architecture) 是一种计算机软件的设计模式,主要应 ...

  6. mongodb副本集数据同步的踩坑

    一.故事 最近随着搞活动比较频繁导致数据库出现了波动,后端日志总是报数据库连接和读取的问题.由于我设置的是读写分离(伪的,通过设置副本集的读取策略实现的,设置的db.getMongo().setRea ...

  7. SSM整合Shiro 身份验证及密码加密简单实现

    1.导入maven的相关依赖 <!-- shiro --> <dependency> <groupId>org.apache.shiro</groupId&g ...

  8. [NOI 2016]国王饮水记

    Description 题库链接 给出 \(n\) 个水杯,每个水杯装有不同高度的水 \(h_i\) ,每次可以指定任意多水杯用连通器连通后断开,问不超过 \(k\) 次操作之后 \(1\) 号水杯的 ...

  9. ASP.NET MVC应用程序播放AVI视频

    前面Insus.NET实现一系列在MVC应用程序播放SWF, FLV, WMV, RM, RMVB视频.每篇使用不同的方法方式,大同小异.这篇中,为了MVC应用程序播放AVI视频,用纯M, V, C来 ...

  10. SQLServer 里面的 DDL,DML,DCL,TCL

    1.DDL (Data Definition Language )数据库定义语言 statements are used to define the database structure or sch ...