文章目录
前言
二叉搜索树是最基础的树结构，本节将从最基础的代码及原理讲起，讲二分搜索树完整的呈现出来。欢迎关注。
一.二分搜索树
1.树的介绍
树是一种数据结构，它是由n(n>=1)个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：
每个节点有零个或多个子节点；没有父节点的节点称为根节点；每一个非根节点有且只有一个父节点；除了根节点外，每个子节点可以分为多个不相交的子树。
2.二分搜索树
1.节点，左孩子，右孩子
节点分根部节点和普通节点。根部节点即上图中最上面的节点，树从它开始向下延伸。
而其余节点皆为普通节点
左孩子右孩子：一个节点的左子树和右子树是其左孩子，右孩子。也是其左子树，右子树。
2.主要特点
可以明显的看出，二分搜索树的节点左边总是比右边小。左子树总是比右子树小。
二、基础方法详解
1.Comparable
所有可以 “排序” 的类都实现了java.lang.Comparable接口，Comparable接口中只有一个方法。
public int compareTo(Object obj)
该方法：
返回 0 表示 this == obj
返回整数表示 this > obj
返回负数表示 this < obj
2.成员变量
为树设置一个头结点，然后头结点的左边有左孩子，右边有右孩子。再对left和right进行初始化
代码如下
public class BST<E extends Comparable<E>>{
public class Node{
public E e;
public Node left,right;
public Node(E e){
this.e=e;
left =null;
right=null;
}
}
3.基础方法及基础变量的定义
可见代码
private Node root;
private int size;
public BST(){
root=null;
size=0;
}
public int size(){
return size;
}
public boolean isEmpty(){
return size==0;
}
其中，getSize()用来获取树的长度，而isEmpty()为布尔型，用来判断树是否为空。
三.主要方法详解
1.以node为根向二分搜索树中添加新的元素
我们只需知道要添加的元素是什么。然后先与根部节点进行比较，若比节点小则将此元素与根部节点的左结点进行比较；若比结点大则将此元素与根部节点的右结点进行比较。若比左结点小则与左结点的左结点进行比较，反之右结点也是一样。（依据二分搜索树的特点）
以下是相关代码，请读者朋友细细体会
//向二分搜索树种添加新的元素e
public void add(E e){
root=add(root,e);
}
//向以node为根的二分搜索树中插入元素E,递归算法设置node是为了不断转换找到真正要插入的位置
public Node add(Node node,E e){
//递归终止条件
if(node==null){
size++;
return new Node(e);
}//为空插入新节点
if(e.compareTo(node.e)<0)//如果插入元素比根部元素小
node.left=add(node.left,e);//以左结点为根部从新开始往下运行程序
else if(e.compareTo(node.e)>0)
node.right=add(node.right,e);//反正，以右结点为根部从新开始往下运行程序
//左孩子右孩子重新赋值
return node;//返回根节点
}
//查找是否包含元素e
public boolean contains(E e){
return contains(root,e);
}
2.看以node为根的二分搜索树中是否包含元素e
具体思路是对二分搜索树进行遍历，边遍历边用上述方法与元素e进行比较，如果比e小则去e的左子树中找，如果比e大则与e的右子树中找。
这是个布尔类型的函数，具体比较逻辑与方法与上述类似，不再赘述。
代码如下
//查找是否包含元素e
public boolean contains(E e){
return contains(root,e);
}
//看以node为根的二分搜索树中是否包含元素e
private boolean contains(Node node,E e){
if(node==null)
return false;
if(e.compareTo(node.e)==0)
return true;
else if(e.compareTo(node.e)<0)
contains(node.left,e);
else//e.compareTo(node.e>0)
return contains(node.right,e);
return false;
}
3.寻找二分搜索树中的最小，最大元素
由二分搜索树的特点可知，左边元素比右边元素要小，那么最小的元素实际上是最左边的元素。同理，最右边的元素是最大的元素。所以只需要遍历即可。
寻找最小元素代码如下
//寻找二分搜索树中的最小元素
public E minimum(){
if(size==0)
throw new IllegalArgumentException("BST is empty");
return minimum(root).e;
}
//返回以node为根的二分搜索树最小值所在的节点
private Node minimum(Node node){
if(node.left==null)
return node;
return minimum(node.left);//看左孩子
}
这里实际上有一个递归。递归的是方法minimum。实际上看一个节点，若节点不为空，则将此节点的左结点再拿来比较。若结点为空，则返回此节点的e。
与此逻辑相似的是寻找最大节点。代码如下
//寻找二分搜索树的最大元素
public E maxinum(){
if(size==0)
throw new IllegalArgumentException("BST is empty");
return maxinum(root).e;
}
//返回以node为根的二分搜索树的最大值所在的节点
private Node maxinum(Node node){
if(node.right==null)
return node;
return maxinum(node.right);
}
4.元素的删除
代码有详细注释。结合代码来阐明逻辑
//删除以node为根的二分搜索树中值为e的节点，递归算法
//返回删除节点后的新的二分搜索树的根
private Node remove(Node node,E e){
if(node==null)
return null;
if(e.compareTo(node.e)<0){
node.left=remove(node.left,e);
return node;//要删除元素比结点元素小，继续找更小的
}
else if(e.compareTo(node.e)>0){
node.right=remove(node.right,e);//要删除元素比结点元素大，继续找更大的
}
else{//e==node.e找到了要删除的结点
if(node.left==null){//如果该节点是最小的而结点右边存在元素
Node rightNode=node.right;//把右孩子储存
node.right=null;//另原来存放右孩子的地方为空
size--;//数量减小
return rightNode;//返回储存的那个结点
}
if(node.right==null){//如果要删除的元素右边为空
Node leftNode=node.left;//储存该节点左孩子
node.left=null;//另之前存放左孩子的地方为空
size--;//数量减小
return leftNode;//返回储存的左孩子
}
//待删除节点左右字数均不为空的情况
//找到比待删除节点大的最小节点，即待删除节点右子树最小节点
//用这个节点顶替待删除节点的位置
Node successor=minimum(node.right);
successor.right=removeMin(node.right);
successor.left=node.left;
node.left=node.right=null;
return successor;
}
return node;
}
//删除掉以node为根的二分搜索树中的最大节点
//返回删除节点后的二分搜索树的根
private Node removeMin(Node node){
if(node.left==null){
Node rightNode=node.right;
node.right=null;
size--;
return rightNode;
}
node.left=removeMin(node.left);
return node;
}
//从二分搜索树中删除最大值所在的节点
public E removeMax(){
E ret=maxinum();
root=removeMax(root);
return ret;
}
//删除掉以node为根的二分搜索树中的最大节点
//返回删除节点后的二分搜索树的根
private Node removeMax(Node node){
if(node.right==null){
Node leftNode=node.left;
node.left=null;
size--;
return leftNode;
}
node.right=removeMax(node.right);
return node;
}
//从二分搜索树中删除元素为e的节点
public void remove(E e){
root=remove(root,e);
}
五.整体代码（含注释）
import java.util.Stack;
import java.util.Queue;
import java.util.LinkedList;
public class BST<E extends Comparable<E>>{
public class Node{
public E e;
public Node left,right;
public Node(E e){
this.e=e;
left =null;
right=null;
}
}
private Node root;
private int size;
public BST(){
root=null;
size=0;
}
public int size(){
return size;
}
public boolean isEmpty(){
return size==0;
}
//向二分搜索树种添加新的元素e
public void add(E e){
root=add(root,e);
}
//向以node为根的二分搜索树中插入元素E,递归算法设置node是为了不断转换找到真正要插入的位置
public Node add(Node node,E e){
//递归终止条件
if(node==null){
size++;
return new Node(e);
}//为空插入新节点
if(e.compareTo(node.e)<0)//如果插入元素比根部元素小
node.left=add(node.left,e);//以左结点为根部从新开始往下运行程序
else if(e.compareTo(node.e)>0)
node.right=add(node.right,e);//反正，以右结点为根部从新开始往下运行程序
//左孩子右孩子重新赋值
return node;//返回根节点
}
//查找是否包含元素e
public boolean contains(E e){
return contains(root,e);
}
//看以node为根的二分搜索树中是否包含元素e
private boolean contains(Node node,E e){
if(node==null)
return false;
if(e.compareTo(node.e)==0)
return true;
else if(e.compareTo(node.e)<0)
contains(node.left,e);
else//e.compareTo(node.e>0)
return contains(node.right,e);
return false;
}
//二分搜索树的前序遍历
public void preOrder(){
preOrder(root);
}
//前序遍历非递归写法
public void preOrderNR(){
Stack<Node> stack=new Stack<Node>();
stack.push(root);
while(!stack.isEmpty()){
Node cur=stack.pop();
System.out.println(cur.e);
if(cur.right!=null)
stack.push(cur.right);
if(cur.left!=null)
stack.push(cur.left);
}
}
//前序遍历以node为根的二分搜索树，递归算法
//前序遍历是先访问结点再访问子树而后续遍历则相反
private void preOrder(Node node){
if(node==null)
return;
System.out.println(node.e);//把结点树打出来
//熟练掌握可以不先写终止操作，灵活处理
//if(node!=null)
preOrder(node.left);
preOrder(node.right);
}
//中序遍历
public void inOrder(){
inOrder(root);//初始传入一个根
}
//中序遍历以node为根的二分搜索树，递归算法
private void inOrder(Node node){
if(node==null)
return;
inOrder(node.left);
System.out.println(node.e);
inOrder(node.right);
}
//后序遍历
public void postOrder(){
postOrder(root);
}
private void postOrder(Node node){
if(node==null)
return;
postOrder(node.left);
postOrder(node.right);
System.out.println(node.e);
}
//层序遍历,用链表实现队列
public void levelOrderf(){
Queue<Node> q=new LinkedList<Node>();
q.add(root);
while(!q.isEmpty()){
Node cur=q.remove();
System.out.println(cur.e);
if(cur.left!=null)
q.add(cur.left);
if(cur.right!=null)
q.add(cur.right);
}
}
//寻找二分搜索树中的最小元素
public E minimum(){
if(size==0)
throw new IllegalArgumentException("BST is empty");
return minimum(root).e;
}
//寻找二分搜索树的最大元素
public E maxinum(){
if(size==0)
throw new IllegalArgumentException("BST is empty");
return maxinum(root).e;
}
//返回以node为根的二分搜索树的最大值所在的节点
private Node maxinum(Node node){
if(node.right==null)
return node;
return maxinum(node.right);
}
//返回以node为根的二分搜索树最小值所在的节点
private Node minimum(Node node){
if(node.left==null)
return node;
return minimum(node.left);//看左孩子
}
//从二分搜索树中删除最小值所在的节点
public E removeMin(){
E ret=minimum();
root=removeMin(root);
return ret;
}
//删除掉以node为根的二分搜索树中的最大节点
//返回删除节点后的二分搜索树的根
private Node removeMin(Node node){
if(node.left==null){
Node rightNode=node.right;
node.right=null;
size--;
return rightNode;
}
node.left=removeMin(node.left);
return node;
}
//从二分搜索树中删除最大值所在的节点
public E removeMax(){
E ret=maxinum();
root=removeMax(root);
return ret;
}
//删除掉以node为根的二分搜索树中的最大节点
//返回删除节点后的二分搜索树的根
private Node removeMax(Node node){
if(node.right==null){
Node leftNode=node.left;
node.left=null;
size--;
return leftNode;
}
node.right=removeMax(node.right);
return node;
}
//从二分搜索树中删除元素为e的节点
public void remove(E e){
root=remove(root,e);
}
//删除以node为根的二分搜索树中值为e的节点，递归算法
//返回删除节点后的新的二分搜索树的根
private Node remove(Node node,E e){
if(node==null)
return null;
if(e.compareTo(node.e)<0){
node.left=remove(node.left,e);
return node;//要删除元素比结点元素小，继续找更小的
}
else if(e.compareTo(node.e)>0){
node.right=remove(node.right,e);//要删除元素比结点元素大，继续找更大的
}
else{//e==node.e找到了要删除的结点
if(node.left==null){//如果该节点是最小的而结点右边存在元素
Node rightNode=node.right;//把右孩子储存
node.right=null;//另原来存放右孩子的地方为空
size--;//数量减小
return rightNode;//返回储存的那个结点
}
if(node.right==null){//如果要删除的元素右边为空
Node leftNode=node.left;//储存该节点左孩子
node.left=null;//另之前存放左孩子的地方为空
size--;//数量减小
return leftNode;//返回储存的左孩子
}
//待删除节点左右字数均不为空的情况
//找到比待删除节点大的最小节点，即待删除节点右子树最小节点
//用这个节点顶替待删除节点的位置
Node successor=minimum(node.right);
successor.right=removeMin(node.right);
successor.left=node.left;
node.left=node.right=null;
return successor;
}
return node;
}
@Override
public String toString(){
StringBuilder res=new StringBuilder();
generateBSTString(root,0,res);//res是要打印的一套节点
return res.toString();
}
private void generateBSTString(Node node,int depth,StringBuilder res){
if(node==null){
res.append(generateDepthString(depth)+"null\n");
return;//如果节点为空，打印应有杠和null
}
//节点不为空的时候
res.append(generateDepthString(depth)+node.e+"\n");//打印横杠并打印节点对应元素
generateBSTString(node.left,depth+1,res);//左结点递归
generateBSTString(node.right,depth+1,res);//右结点递归
}
private String generateDepthString(int depth){
StringBuilder res=new StringBuilder();
for(int i=0;i<depth;i++)//遍历了depth次
res.append("--");//depth是用来打印--的
return res.toString();
}
}
总结
树比较重要的还有啥树的三种递归遍历及无需递归的遍历，将在后续博客中慢慢更新，谢谢关注！
1321
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
