首页 > 代码库 > 二叉查找树
二叉查找树
二叉查找(搜索)树（Binary Search Tree）又称二叉排序树(Binary Sort Tree),是基于二叉树，BST具有下列性质：
1、若左子树不空，则其左子树上的所有结点的值均小于根结点的值；
2、若右子树不空，则其右子树上的所有结点的值均大于根结点的值；
3、左、右子树也分别为二叉查找树。
结点类
public class BinaryNode {
Integer data;
BinaryNode leftChild;
BinaryNode rightChild;
public BinaryNode() {
}
public BinaryNode(int data) {
leftChild = null;
rightChild = null;
this.data = data;
}
public BinaryNode(Integer data, BinaryNode leftChild, BinaryNode rightChild) {
this.data = data;
this.leftChild = leftChild;
this.rightChild = rightChild;
}
}
Integer data;
BinaryNode leftChild;
BinaryNode rightChild;
public BinaryNode() {
}
public BinaryNode(int data) {
leftChild = null;
rightChild = null;
this.data = data;
}
public BinaryNode(Integer data, BinaryNode leftChild, BinaryNode rightChild) {
this.data = data;
this.leftChild = leftChild;
this.rightChild = rightChild;
}
}
二叉查找树实现类
public class BinarySearchTree {
private BinaryNode root;
List<BinaryNode> nodeList = new LinkedList<BinaryNode>();
//相关方法 。。。。
}
private BinaryNode root;
List<BinaryNode> nodeList = new LinkedList<BinaryNode>();
//相关方法 。。。。
}
1、插入操作
/**
* 非递归插入操作x的过程如下：
* 1、若b是空树，则直接将插入的结点作为根结点插入。
* 2、x等于b的根结点的数据的值，则直接返回，否则。
* 3、若x小于b的根结点的数据的值，则将x要插入的结点的位置改变为b的左子树，否则。
* 4、将x要出入的结点的位置改变为b的右子树。
*/
public boolean insert(Integer value) {
if (root == null) {
root = new BinaryNode(value); //新构造一个二叉查找树
nodeList.add(root);
} else {
BinaryNode parent = null;
BinaryNode current = root;
while (current != null) {
//compareTo就是比较两个值，如果前者大于后者，返回1，等于返回0，小于返回-1
if (value.compareTo(current.data) == -1) {
parent = current;
current = current.leftChild;
} else if (value.compareTo(current.data) == 1) {
parent = current;
current = current.rightChild;
} else
return false;
}
if (value.compareTo(parent.data) == -1)
parent.leftChild = new BinaryNode(value);
else
parent.rightChild = new BinaryNode(value);
nodeList.add(parent);
}
return true;
}
* 非递归插入操作x的过程如下：
* 1、若b是空树，则直接将插入的结点作为根结点插入。
* 2、x等于b的根结点的数据的值，则直接返回，否则。
* 3、若x小于b的根结点的数据的值，则将x要插入的结点的位置改变为b的左子树，否则。
* 4、将x要出入的结点的位置改变为b的右子树。
*/
public boolean insert(Integer value) {
if (root == null) {
root = new BinaryNode(value); //新构造一个二叉查找树
nodeList.add(root);
} else {
BinaryNode parent = null;
BinaryNode current = root;
while (current != null) {
//compareTo就是比较两个值，如果前者大于后者，返回1，等于返回0，小于返回-1
if (value.compareTo(current.data) == -1) {
parent = current;
current = current.leftChild;
} else if (value.compareTo(current.data) == 1) {
parent = current;
current = current.rightChild;
} else
return false;
}
if (value.compareTo(parent.data) == -1)
parent.leftChild = new BinaryNode(value);
else
parent.rightChild = new BinaryNode(value);
nodeList.add(parent);
}
return true;
}
递归插入：
/**
* 递归插入: 得到的nodeList的size不是插入数据的大小！！！
*/
public BinaryNode recursiveInsert(Integer value) {
return recursiveInsert(value, this.root);
}
private BinaryNode recursiveInsert(Integer value, BinaryNode node) {
if (root == null)
root = new BinaryNode(value); //新构造一个二叉查找树
if (node == null) //如果是叶节点，则没有孩子
return new BinaryNode(value, null, null);
int result = value.compareTo(node.data);
/![技术分享]()
alue小于node.data返回-1
if (result == -1) {
node.leftChild = recursiveInsert(value, node.leftChild);
} else if (result == 1) {
node.rightChild = recursiveInsert(value, node.rightChild);
}
nodeList.add(node);
return node;
}
* 递归插入: 得到的nodeList的size不是插入数据的大小！！！
*/
public BinaryNode recursiveInsert(Integer value) {
return recursiveInsert(value, this.root);
}
private BinaryNode recursiveInsert(Integer value, BinaryNode node) {
if (root == null)
root = new BinaryNode(value); //新构造一个二叉查找树
if (node == null) //如果是叶节点，则没有孩子
return new BinaryNode(value, null, null);
int result = value.compareTo(node.data);
/
if (result == -1) {
node.leftChild = recursiveInsert(value, node.leftChild);
} else if (result == 1) {
node.rightChild = recursiveInsert(value, node.rightChild);
}
nodeList.add(node);
return node;
}
测试：
@Test
public void test() {
BinarySearchTree tree = new BinarySearchTree();
BinarySearchTree tree1 = new BinarySearchTree();
int[] keys = new int[] { 8, 3, 10, 1, 6, 14, 4, 7, 13 };
for (int key:keys){
tree.insert(key);
tree1.recursiveInsert(key);
}
List<BinaryNode> list = tree.getBinarySearchTree();
List<BinaryNode> list1 = tree1.getBinarySearchTree();
System.out.println("非递归插入节点后，树的大小："+ list.size());
System.out.println("递归插入节点后，树的大小：" + list1.size());
}
public void test() {
BinarySearchTree tree = new BinarySearchTree();
BinarySearchTree tree1 = new BinarySearchTree();
int[] keys = new int[] { 8, 3, 10, 1, 6, 14, 4, 7, 13 };
for (int key:keys){
tree.insert(key);
tree1.recursiveInsert(key);
}
List<BinaryNode> list = tree.getBinarySearchTree();
List<BinaryNode> list1 = tree1.getBinarySearchTree();
System.out.println("非递归插入节点后，树的大小："+ list.size());
System.out.println("递归插入节点后，树的大小：" + list1.size());
}
非递归插入节点后，树的大小：9
递归插入节点后，树的大小：17
递归插入节点后，树的大小：17
2、删除操作
对于二叉查找树的删除操作（这里根据值删除，而非结点）分三种情况：
不过在此之前，我们应该确保根据给定的值找到了要删除的结点，如若没找到该结点不会执行删除操作！这里暂时没有考虑
下面三种情况假设已经找到了要删除的结点。
1、如果结点为叶子结点（没有左、右子树），此时删除该结点不会玻化树的结构直接删除即可，并修改其父结点指向它的引用为null.如下图:
2、如果其结点只包含左子树，或者右子树的话，此时直接删除该结点，并将其左子树或者右子树设置为其父结点的左子树或者右子树即可，此操作不会破坏树结构。
3、当结点的左右子树都不空的时候，一般的删除策略是用其右子树的最小数据（容易找到）代替要删除的结点数据并递归删除该结点（此时为null），因为右子树的最小结点不可能有左孩子，所以第二次删除较为容易。z的左子树和右子树均不空。找到z的后继y，因为y一定没有左子树，所以可以删除y，并让y的父亲节点成为y的右子树的父亲节点，并用y的值代替z的值.如图：
实现代码：
public void remove(Integer value) {
this.root = remove(value,root);
}
/**
* 递归删除：
*
* eg:添加的节点顺序为8，3，9.删除根结点，返回值则为3
* @return 返回值始终是最新的根节点！！！
*/
private BinaryNode remove(Integer value, BinaryNode node) {
if (node == null)
return null;
int result = value.compareTo(node.data);
//result<0：表示需要删除的节点在左子树
if (result == -1) {
node.leftChild = remove(value, node.leftChild);
} else if (result == 1) {//在右子树
node.rightChild = remove(value, node.rightChild);
} else if (node.leftChild != null && node.rightChild != null) { //结点的左右子树都不时候
//先找到需要删除的节点下，右子树中最小的节点并将它的值赋给需要删除的节点。
node.data = findMin(node.rightChild).data; //找出右子树最小值（因为右子树中的节点的值一定大于根节点）
//删除前面找到的最小的节点
node.rightChild = remove(node.data, node.rightChild);
}else {
//找到需要删除的节点且节点下有一个子节点（左或者右）
node = (node.leftChild != null) ? node.leftChild : node.rightChild;
}
return node;
}
this.root = remove(value,root);
}
/**
* 递归删除：
*
* eg:添加的节点顺序为8，3，9.删除根结点，返回值则为3
* @return 返回值始终是最新的根节点！！！
*/
private BinaryNode remove(Integer value, BinaryNode node) {
if (node == null)
return null;
int result = value.compareTo(node.data);
//result<0：表示需要删除的节点在左子树
if (result == -1) {
node.leftChild = remove(value, node.leftChild);
} else if (result == 1) {//在右子树
node.rightChild = remove(value, node.rightChild);
} else if (node.leftChild != null && node.rightChild != null) { //结点的左右子树都不时候
//先找到需要删除的节点下，右子树中最小的节点并将它的值赋给需要删除的节点。
node.data = findMin(node.rightChild).data; //找出右子树最小值（因为右子树中的节点的值一定大于根节点）
//删除前面找到的最小的节点
node.rightChild = remove(node.data, node.rightChild);
}else {
//找到需要删除的节点且节点下有一个子节点（左或者右）
node = (node.leftChild != null) ? node.leftChild : node.rightChild;
}
return node;
}
3、查找
/**
* 在二叉查找树中查找x的过程如下：
* 1、若二叉树是空树，则查找失败。
* 2、若x等于根结点的数据，则查找成功，否则。
* 3、若x小于根结点的数据，则递归查找其左子树，否则。
* 4、递归查找其右子树。
*/
public boolean find(Integer value) {
return contains(value, this.root);
}
private boolean contains(Integer value, BinaryNode node) {
if (node == null)
return false;
int result = value.compareTo(node.data); //-1,0,1
if (result == -1) {
return contains(value, node.leftChild); //递归查询左子树
}else if (result == 1) {
return contains(value, node.rightChild); //递归查询右子树
} else {
return true;
}
}
* 在二叉查找树中查找x的过程如下：
* 1、若二叉树是空树，则查找失败。
* 2、若x等于根结点的数据，则查找成功，否则。
* 3、若x小于根结点的数据，则递归查找其左子树，否则。
* 4、递归查找其右子树。
*/
public boolean find(Integer value) {
return contains(value, this.root);
}
private boolean contains(Integer value, BinaryNode node) {
if (node == null)
return false;
int result = value.compareTo(node.data); //-1,0,1
if (result == -1) {
return contains(value, node.leftChild); //递归查询左子树
}else if (result == 1) {
return contains(value, node.rightChild); //递归查询右子树
} else {
return true;
}
}
4、其它相关方法
//获取二叉查找树
public List<BinaryNode> getBinarySearchTree() {
return nodeList;
}
/**
* 找出最小的值
* @return 返回最小值
*/
public Integer findMin() {
return findMin(root).data;
}
private BinaryNode findMin(BinaryNode node) {
if (node == null)
return null;
else if (node.leftChild == null) //如果左孩子没有，只返回根结点
return node;
return findMin(node.leftChild);
}
/**
* 找出最大的值
*/
public Integer findMax() {
return findMax(root).data;
}
private BinaryNode findMax(BinaryNode node) {
if (node ==null)
return null;
else if (node.rightChild == null)
return node;
else
return findMax(node.rightChild);
}
public void inOrderTraverse() {
inOrderTraverse(root);
}
/**
* 递归中序排序:
* 二叉查找树中序排序后的二叉查找树是有序的
*/
public void inOrderTraverse(BinaryNode node) {
if (node != null) {
inOrderTraverse(node.leftChild);
System.out.print(node.data + " ");
inOrderTraverse(node.rightChild);
}
}
public List<BinaryNode> getBinarySearchTree() {
return nodeList;
}
/**
* 找出最小的值
* @return 返回最小值
*/
public Integer findMin() {
return findMin(root).data;
}
private BinaryNode findMin(BinaryNode node) {
if (node == null)
return null;
else if (node.leftChild == null) //如果左孩子没有，只返回根结点
return node;
return findMin(node.leftChild);
}
/**
* 找出最大的值
*/
public Integer findMax() {
return findMax(root).data;
}
private BinaryNode findMax(BinaryNode node) {
if (node ==null)
return null;
else if (node.rightChild == null)
return node;
else
return findMax(node.rightChild);
}
public void inOrderTraverse() {
inOrderTraverse(root);
}
/**
* 递归中序排序:
* 二叉查找树中序排序后的二叉查找树是有序的
*/
public void inOrderTraverse(BinaryNode node) {
if (node != null) {
inOrderTraverse(node.leftChild);
System.out.print(node.data + " ");
inOrderTraverse(node.rightChild);
}
}
二叉查找树
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。