BST树功能的实现--------------（非递归方式）
BST树（二叉排序树）：*
一、特点：
1.首先它也是一个二叉树，故满足递归定义;
2 其次每个节点只存在一个值,每个节点只有它的左孩子和右孩子;
3 需满足左子树值<=root(根值)<=右子树，故按照中序遍历会得到递增序列；
4.链表数据结构来表示，其中，每一个结点就是一个对象；
给定如下序列及其对应得二叉排序树：
BTS树可看作是一个链表，因此在操作时可按照链表的进行定义和操作
1.定义节点数据类型属性
/**
* BST树的节点类型
* @param <T>
*/
class BSTNode<T extends Comparable<T>>{
private T data; // 数据域
private BSTNode<T> left; // 左孩子域
private BSTNode<T> right; // 右孩子域
public BSTNode(T data, BSTNode<T> left, BSTNode<T> right) {
this.data = data;
this.left = left;
this.right = right;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public BSTNode<T> getLeft() {
return left;
}
public void setLeft(BSTNode<T> left) {
this.left = left;
}
public BSTNode<T> getRight() {
return right;
}
public void setRight(BSTNode<T> right) {
this.right = right;
}
}
2.定义BST树
/**
* BST树的实现
* @param <T>
*/
class BST<T extends Comparable<T>>{
private BSTNode<T> root; // 指向根节点
/**
* BST树的初始化
*/
public BST() {
this.root = null;
}
（3）实现功能
插入功能：
非递归方式：
/**
* BST树的非递归插入操作
* @param data
*/
public void non_insert(T data){
// 1.判断如果root是null，如果root是null，直接生成根节点，让root指向，结束
if(root == null){
this.root = new BSTNode<>(data, null, null);
return;
}
// 2.如果root不为空，从根节点开始搜索一个合适的位置，放新节点
BSTNode<T> cur = this.root;
BSTNode<T> parent = null; // this.root
while(cur != null){
if(cur.getData().compareTo(data) > 0){
parent = cur;
cur = cur.getLeft();
} else if(cur.getData().compareTo(data) < 0){
parent = cur;
cur = cur.getRight();
} else {
return;
}
}
// 3.生成新节点，把节点的地址，写入父节点相应的地址域
if(parent.getData().compareTo(data) > 0){
parent.setLeft(new BSTNode<T>(data, null, null));
} else {
parent.setRight(new BSTNode<T>(data, null, null));
}
}
插入（递归方式）
//插入
public void insert(T data) {
root = insert(this.root, data);
}
public BSTNode<T> insert(BSTNode<T> root, T data) {
if (root == null) {
root = new BSTNode<>(data, null, null);
}
if (root.getData().compareTo(data) > 0) {
root.setLeft(insert(root.getLeft(), data));
} else if (root.getData().compareTo(data) < 0) {
root.setRight(insert(root.getRight(), data));
} else {
root.setData(data);
}
return root;
}
删除功能（非递归方式）：
/*删除操作
*（1）删除有2个孩子的节点：
* 找出该节点的前驱或者后继，用前驱节点（或者后继节点）的值去覆盖当前节点的值
* 前驱节点：待删节点的左子树的最大值
* 后继节点：待删节 点的右子树最小值
* （2）删除1个孩子的节点
* （3）删除叶子节点
* 删除1个或0个孩子的节点。其前驱或者后继只有一个，此时我们至于要将待删节点写入待删节点的父节点中即可
* */
/**
* 非递归实现BST树的删除操作
* @param data
*/
public void non_remove(T data){
if(this.root == null){
return;
}
// 1. 先搜索BST树，找到待删除的节点
BSTNode<T> cur = this.root;
BSTNode<T> parent = null;
while(cur != null){
if(cur.getData().compareTo(data) > 0){
parent = cur;
cur = cur.getLeft();
} else if(cur.getData().compareTo(data) < 0){
parent = cur;
cur = cur.getRight();
} else {
break;
}
}
if(cur == null){ // 表示BST树中没有值为data的节点
return;
}
// 2. 判断删除节点是否有两个孩子，如果有，用前驱的值代替，直接删除前驱
if(cur.getLeft() != null && cur.getRight() != null){
// 找前驱节点，用前驱节点的值代替待删节点的值，然后直接删除前驱节点cur
BSTNode<T> old = cur;
parent = cur;
cur = cur.getLeft();
while(cur.getRight() != null){
parent = cur;
cur = cur.getRight();
}
old.setData(cur.getData()); // 前驱节点的值代替待删节点的值
}
// 3. 删除有一个孩子的节点，或者没有孩子的节点（看作有一个孩子，孩子是null）
BSTNode<T> child = cur.getLeft();
if(child == null){
child = cur.getRight();
}
if(parent == null){ // 删除的就是根节点
this.root = child;
} else {
if(parent.getLeft() == cur){
parent.setLeft(child);
} else {
parent.setRight(child);
}
}
}
删除（递归）
public void remove(T data) {
root = remove(this.root, data);
}
public BSTNode<T> remove(BSTNode<T> root, T data) {
if (root == null) {
return null;
}
if (root.getData().compareTo(data) > 0) {
root.setLeft(remove(root.getLeft(), data));
} else if (root.getData().compareTo(data) < 0) {
root.setRight(remove(root.getRight(), data));
} else {
if (root.getLeft() != null && root.getRight() != null) {
//找前驱
BSTNode<T> pre = root.getLeft();
while (pre.getRight() != null) {
pre = pre.getRight();
}
root.setData(pre.getData());
root.setLeft(remove(root.getLeft(), data));
} else {
if (root.getLeft() != null) {
return root.getLeft();
} else if (root.getRight() != null) {
return root.getRight();
} else {
return null;
}
}
}
return root;
}
查询功能（非递归）：
/**
* 在BST树种，搜索值为data的节点，找到返回true，找不到返回false
* @param data
* @return
*/
public boolean non_query(T data){
BSTNode<T> cur = this.root;
while(cur != null){
if(cur.getData().compareTo(data) > 0){
cur = cur.getLeft();
} else if(cur.getData().compareTo(data) < 0){
cur = cur.getRight();
} else {
return true;
}
}
return false;
}
}
打印输出序列
分三种：V:root L:左孩子 R:右孩子
始终保证左孩子再有孩子前边：
VLR:先序遍历
先遍历V，依次遍历v的左孩子，Vd的左孩子的左孩子，直到左孩子为null，在开始遍历右孩子（对于每一个节点来说他都是他孩子节点的root节点，每个节点递归的按照VLR遍历）
58 23 18 35 29 47
LVR:中序遍历
18 23 29 35 47 58 68
LRV:后序遍历
18 29 47 35 92 68 58
前序遍历(递归实现):
/**
* 前序遍历BST树的API接口
*/
public void preOrder(){
System.out.print("递归前序遍历:");
preOrder(this.root);
System.out.println();
}
/**
* 前序遍历BST树的递归操作 VLR
* @param root
*/
private void preOrder(BSTNode<T> root) {
if(root != null){
System.out.print(root.getData() + " ");
preOrder(root.getLeft());
preOrder(root.getRight());
}
}
中序遍历（递归）
/**
* 中序遍历BST树的API接口
*/
public void inOrder(){
System.out.print("递归中序遍历:");
inOrder(this.root);
System.out.println();
}
/**
* 中序遍历BST树的递归操作 LVR
* @param root
*/
private void inOrder(BSTNode<T> root) {
if(root != null){
inOrder(root.getLeft());
System.out.print(root.getData() + " ");
inOrder(root.getRight());
}
}
后序遍历（递归）
/**
* 后序遍历BST树的API接口
*/
public void postOrder(){
System.out.print("递归后序遍历:");
postOrder(this.root);
System.out.println();
}
/**
* 中序遍历BST树的递归操作 LRV
* @param root
*/
private void postOrder(BSTNode<T> root) {
if(root != null){
postOrder(root.getLeft());
postOrder(root.getRight());
System.out.print(root.getData() + " ");
}
}
BST树节点个数
/**
* 返回BST树中所有节点个数的API
* @return
*/
public int number(){
return number(this.root);
}
/**
* 以root为根节点计算BST树的节点个数
* @param root
* @return
*/
private int number(BSTNode<T> root) {
if(root == null){
return 0;
} else {
return number(root.getLeft()) + number(root.getRight()) + 1;
}
}
BST树的高度（层数）
/**
* 返回BST树的高度/层数的API
* @return
*/
public int level(){
return level(this.root);
}
/**
* 计算以root为根节点的BST树的高度
* @param root
* @return
*/
private int level(BSTNode<T> root) {
if(root == null){
return 0;
} else {
int left = level(root.getLeft());
int right = level(root.getRight());
return left > right ? left+1 : right+1;
}
}
层序遍历：
每一层从左向右遍历完后在向下一层遍历，因此需要获取树的层数
/**
* 层序遍历BST树的API接口
*/
public void levelOrder(){
System.out.print("递归层序遍历:");
int hight = level();
for (int i = 0; i < hight; i++) {
levelOrder(this.root, i);
}
System.out.println();
}
/**
* 层序遍历的递归实现
* @param root
* @param i
*/
private void levelOrder(BSTNode<T> root, int i) {
if(root != null){
if(i == 0){
System.out.print(root.getData() + " ");
return;
}
levelOrder(root.getLeft(), i-1);
levelOrder(root.getRight(), i-1);
}
}
镜像反转：
将树的左右子树进行交换输出（由大到小）
public void mirror(){
mirror(this.root);
}
public void mirror(BSTNode<T>root){
if (root==null) {
return;
}
//将左右子树进行调换
BSTNode<T>temp=root.getLeft();
root.setLeft(root.getRight());
root.setRight(temp);
mirror(root.getLeft());
mirror(root.getRight());
}
找出begin到end之间的date
public void Date(T begin,T end){
Date(this.root,begin ,end );
}
public void Date(BSTNode<T>root,T begin,T end){
if (root==null){
return ;
}
if(root.getData().compareTo(begin)>0){
Date(root.getLeft(), begin, end);
}
//判断便利的当前节点与begin比较
if(root.getData().compareTo(begin)>0&&root.getData().compareTo(end)>0){
//向左遍历
Date(root.getLeft(), begin, end);
}if (root.getData().compareTo(begin)>=0&&root.getData().compareTo(end)<=0){
Date(root.getRight(),begin ,end );
}
if (root.getData().compareTo(end)<0){
Date(root.getRight(), begin, end);
}
}
判断是不是一颗BST树：
l利用到中序遍历
public boolean isBST(){
T value=null;//用于记录中序遍历过程中的值
return isBST(this.root,value);
}
public boolean isBST(BSTNode<T>root,T value) {
if (root == null) {
return true;
}
if (!isBST(root.getLeft(), value)) {
return false;
}
if (value != null && value.compareTo(root.getData()) > 0) {
return false;
}
value = root.getData();
return isBST(root.getRight(), value);
}
public boolean isBST(BSTNode<T>root){
if (root==null){
return true;
}
if(root.getLeft()!=null&&root.getData().compareTo(root.getLeft().getData())<0){
return false;
}if (root.getRight()!=null&&root.getData().compareTo(root.getRight().getData())>0)0){
return false;
}
return isBST(root.getLeft())&&isBST(root.getRight());
}
元素data1和data2的最近公共祖先（递归方式）
public void ORA(){
T data1=null;
T data2=null;
ORA(this.root, data1, data2);
}
public T ORA( BSTNode<T>root,T data1,T data2){
if(root==null){
return null;
}if (root.getData().compareTo(data1)<0&&root.getData().compareTo(data2)<0){
//在右子树上，向有遍历
return ORA(this.root.getRight(),data1 ,data2 );
}
else if (root.getData().compareTo(data1)>0&&root.getData().compareTo(data2)>0){
return ORA(this.root.getLeft(),data1 ,data2 );
}
return root.getData();
}
判断是不是BST树的子树（递`归）
public boolean isChildTree(BST<T> tree){
BSTNode<T> cur = this.root;
// 在当前BST树上找值为tree.root.getData()的节点
while(cur != null){
if(cur.getData().compareTo(tree.root.getData()) > 0){
cur = cur.getLeft();
} else if(cur.getData().compareTo(tree.root.getData()) < 0){
cur = cur.getRight();
} else {
break;
}
}
if(cur == null){
return false;
}
return isChildTree(cur, tree.root);
}
private boolean isChildTree(BSTNode<T> f, BSTNode<T> c) {
if(f == null && c == null){
return true;
}
if(f == null){
return false;
}
if(c == null){
return true;
}
if(f.getData().compareTo(c.getData()) != 0){
return false;
}
return isChildTree(f.getLeft(), c.getLeft())
&& isChildTree(f.getRight(), c.getRight());
}
BST树的重建（递归）
通过前序遍历可以知道根节点，通过中序遍历可以知道根节点的左子树和右子树的元素，通过前序遍历得到的跟节点去在中序遍历中找到根节点位置，则中序遍历的左边均为左子树元素，右边为右子树元素。
/**
* pre前序数组的[i,j]数据范围，in中序数组的[m,n]数据范围，
* 创建一颗二叉树，并把树的根节点进行返回
* @param pre
* @param i
* @param j
* @param in
* @param m
* @param n
* @return
*/
利用前序，中序重建BST树
public void rebulid(){
}
public BSTNode<T> rebulid(T[]pre,T[]in){
BSTNode<T>root=rebulid(pre,0,pre.length -1, in,0, in.length-1);
return root;
}
public BSTNode<T> rebulid(T[]pre,int i,int j,T[]in,int m,int n){
if(i>j||m>n){
return null;
}
BSTNode<T>root=new BSTNode<>(pre[i],null ,null );
for(int k=m;k<n;k++){
if(pre[i].compareTo(in[k])==0){
//创建左右子树,通过递归rebulid(),找到孩子对应（但还未连接 ）位置，通过回溯setleft()和setright()将当前的左右子树的地质写进父节点
root.setLeft(rebulid(pre, i+1, i+(k-m), in,m ,k-1 ));
root.setRight(rebulid(pre, i+(k-m)+1, j ,in , k+1,m ));
break;
}
}
return root;
}
}
测试代码：
public class TestBST {
public static void main(String[] args) {
BSTTree<Integer>bst=new BSTTree<>();
int[]arr={18,23,29,35,47,58,68};
for(int a:arr) {
bst.insert(a);
}
bst.remove(12);
bst.preOder();
System.out.println("============");
bst.inSort();
System.out.println("============");
bst.postSort();
bst.getHigh();
bst.numData();
bst.levelSort();
bst.mirror();
System.out.println();
}
上边是部分测试代码，想测试其他函数，自己调用就好
判断是不是BST树测试
BST<Integer> bst = new BST<>();
BSTNode<Integer> node1 = new BSTNode<>(40, null, null);
BSTNode<Integer> node2 = new BSTNode<>(20, null, null);
BSTNode<Integer> node3 = new BSTNode<>(10, null, null);
BSTNode<Integer> node4 = new BSTNode<>(50, null, null);
BSTNode<Integer> node5 = new BSTNode<>(80, null, null);
BSTNode<Integer> node6 = new BSTNode<>(30, null, null);
BSTNode<Integer> node7 = new BSTNode<>(90, null, null);
node1.setLeft(node2);
node1.setRight(node5);
node2.setLeft(node3);
node2.setRight(node4);
node5.setLeft(node6);
node5.setRight(node7);
bst.root = node1;
System.out.println(bst.isBSTree());
1160
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
