树结构
高效：数据使用树结构存储后，出奇的高效
二叉树
和链表一样，是动态数据结构
左右孩子为空，就是叶子节点。
和链表一样，具有天然的递归结构
二叉树不一定是满的，哪怕只有一个根节点、一个空，都能看成二叉树
二分搜索树
二分搜索树是二叉树
二分搜索树每个节点的值：（为了快速查询）
大于其左子树的所有节点的值
小于其右子树的所有节点的值
每一棵子树都是二分搜索树
存储的元素必须有可比较性
二分搜索树添加元素
本次学习过程中默认不包含重复元素
但是在应用中，只需要定义：左子树小于等于节点，或者右子树大于等于节点。就行
数据和链表没这个限制
二分搜索树添加元素采用非递归方法时和链表很像；本课主要关注递归实现
在二分搜索树方面，递归比非递归简单很多
二分搜索树查询、遍历
遍历就是把所有节点都访问一遍
访问的原因与业务相关
线性结构下， 遍历是极其容易的，树结构下，稍微有点难度
对于遍历操作，两棵子树都要顾及
前序遍历：最自然，最常用的遍历方式
中序遍历：输出按从小到大排序后的结果
后序遍历：为二分搜索树释放内存
二分搜索树前序遍历的非递归写法：栈
先压入右侧
（跳跃点看，大概是这个意思）
最后遍历完毕
层序遍历（广度优先遍历）
更快找到问题的解；常用于算法设计里找最短路径
图 中，也存在深度优先遍历和广度优先遍历
删除节点
Hibbard Deletion
或者
package com.dataStructrue.tree.BST;
import java.util.LinkedList;
import java.util.Stack;
import java.util.Queue;
public class BST <E extends Comparable<E>>{//满足可比较性条件
//定义二分搜索树
private 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;
}
//向二分搜索树中添加代码
public void add(E e){
if(root==null){
root=new Node(e);
size++;
}
else {
add(root,e);
}
}
//向以node为根的二分搜索树中插入元素E，递归算法
// private void add(Node node,E e){
//
// //递归的终止条件
// if(e.equals(node.e))
// return;
// else if(e.compareTo(node.e)<0&&node.left==null) { //e为E类，满足Comparable<E>条件，调用compareTo语法
// node.left=new Node(e);
// size++;
// return;
// }
// else if (e.compareTo(node.e)>0&&node.right==null){
// node.right=new Node(e);
// size++;
// return;
// }
// //递归的主体语句
// if(e.compareTo(node.e)<0)
// add(node.left,e);
// else
// add(node.right,e);//相等的情况在一开始就判断了
// }
//向以node为根的二分搜索树中插入元素E，递归算法
//返回插入新节点后二分搜索树的根
private 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;
}
//二分搜索树中查询元素
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)
return contains(node.left,e);
else
return contains(node.right,e);
}
//二分搜索树的前序遍历
public void preOrder(){
preOrder(root);
}
//前序遍历以node为根的二分搜索树，递归算法
private void preOrder(Node node){
if(node==null)
return;
// if(node!=null) {
System.out.println(node.e);
preOrder(node.left);
preOrder(node.right);
// }
}
//前序遍历以node为根的二分搜索树，非递归算法
public void preOrderNR(){
Stack<Node>stack=new Stack<>();
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);
}
}
@Override
public String toString(){
StringBuilder res=new StringBuilder();
generateBSTString(root,0,res);
return res.toString();
}
//生成以node为根节点，深度为depth的描述二叉树的字符串
private void generateBSTString(Node node,int depth,StringBuilder res){
if(node==null){
res.append(generateDepthString(depth)+"null\n");
return;
}
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++) {
res.append("--");
}
return res.toString();
}
//二分搜索树的中序遍历
public void inOrder(){
inOrder(root);
}
//中序遍历以node为根的二分搜索树，递归算法
public void inOrder(Node node){
if(node==null)
return;
inOrder(node.left);
System.out.println(node.e);
inOrder(node.right);
}
//后续遍历
public void postOrder(){
postOrder(root);
}
//后序遍历以node为根的二分搜索树，递归算法
public void postOrder(Node node){
if(node==null)
return;
postOrder(node.left);
postOrder(node.right);
System.out.println(node.e);
}
//层序遍历（又称广度遍历）
public void levelOrder(){
Queue<Node> q=new LinkedList<>();
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("empty");
return minimum(root).e;
}
private Node minimum(Node node){
if(node.left==null)
return node;
return minimum(node.left);
}
public E maximum(){
if(size==0)
throw new IllegalArgumentException("empty");
return maximum(root).e;
}
private Node maximum(Node node){
if(node.right==null)
return node;
return minimum(node.right);
}
//删除二分搜索树的最值(删除中间节点后，后续节点接上节点）
//二分搜索树中删除最小值所在节点，返回最小值
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=maximum();
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;
}
if(e.compareTo(node.e)>0) {
node.right = remove(node.right, e);
return node;
}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;
}
}
}
24万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
