1、树
- 树是一种天然的组织结构
2、二叉树
- 每个节点最多只有两个分支
- 每个节点最多只有一个父亲节点
- 和链表一样具有动态的特点
每个节点的定义：
public class Node{
private E e;
private Node left;
private Node right;
}
具有一个节点值以及左右两个子树的节点指向。
3、二分搜索树
- 具有一定的顺序性，前提是每个节点值都是可比较的。
- 每个节点的左子树的值都小于该节点
- 每个节点的右子树的值都大于该节点
- 假设我们的节点值都是不重复的
4、二分搜索树的结构
- 成员变量：根节点root，树的大小，也就是节点值的数量size
- 构造方法：root=null; size=0;
- 成员方法：
- int getSzie() 返回二分搜索树的大小
- boolean isEmpty() 返回二分搜索树是否为空
- void add(E e):为二分搜索树添加元素，采用递归的方法
- boolean contains(E e) : 返回二分搜索是是否包含某个元素，同样采用递归的思路
- void preOrder() : 二分搜索树的前序遍历，遍历的思路是先打印该节点的值，然后打印左子树的值，然后打印右子树的值。同样采用递归的思路。遍历的伪码：
private void preOrder(Node node) {
if (node == null) return;
System.out.println(node.e);
preOrder(node.left);
preOrder(node.right);
}
-
void preOrderNR() 前序遍历的非递归写法：我们需要利用栈的数据结构，每次我们把每个节点放进栈之后，进行打印，然后再把该节点的右，左子树依次放进栈里，然后再重复同样的操作，知道栈中没有元素为止。
-
void InOrder() :中序遍历，这里遍历的结果有个特点就是，遍历的结果是按照从小到大的顺序。遍历的顺序特点就是，先打印节点的左子树的值，然后再打印该节点的值，最后打印右子树的值。改成下面的顺序即可。
inOrder(node.left);
System.out.println(node.e);
inOrder(node.right); -
void postOrder(): 后序遍历，先打印左子树的值，再打印右子树的值，最后打印节点的值：代码改成下面的顺序即可。
postOrder(node.left);
postOrder(node.right);
System.out.println(node.e); -
levelOrder() 广度优先遍历：就是按照树的深度一层一层的进行遍历打印，这里我们需要用到队列的数据结构。就是把一个节点进行入队，然后进行出队的操作，打印该节点的值，然后把该节点的左右子树进行入队的操作，知道队列为空。这样就完成了我们的广度优先遍历的结果。
-
E minmum() 寻找二分搜索树的最小值，根据该树的顺序性，我们知道做小值在树的最左端，我们只需要不断递归到树的最左端，知道该节点的左子树为空就是我们需要的最小值。寻找最大值同理。
-
E removeMin()： 删除最小值并返回。首先根据上面的方法，我们找到最小值。然后保存该节点的右子树，释放该节点的右子树，然后返回右子树的根节点。该方法为递归算法。删除最大值并返回也是同理的。
-
void remove(E e) :删除二分搜索树元素为e 的节点。首先遍历，如果没有找到，则返回null。如果找到的了话，我们我们首先判断，该节点的左右子树是否为空，如果有一个为空的话，我们和删除最大和最小值得思路一样进行操作。如果都不为空，我们为遵循下面的思路，首先找到右子树的最小值节点，让该节点的右子树连接到删除该节点的右子树，左子树连接到原来的左子树根节点，然后让我们要删除的节点的左右都指向null，并返回我们重新设置的节点即可。
到这里就把该类的主要方法都简要的描述完了，下面看一下具体的代码实现：
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
/**
* 二分搜索树（binary search tree)
* BST
*
* @param <E> 我们实现的二分搜索树不包含重复的元素
* 非递归的写法
*/
public class BST<E extends Comparable<E>> {
// 节点的内部类
private class Node {
public E e;
public Node left;
public Node 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 getSize() {
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);
// }
// }
// 私有的递归插入算法
// 递归的想法是每个节点都是一个二叉树
// private void add(Node node, E e) {
// // 判断递归终止的条件
// if (e.compareTo(node.e) == 0) return;
// else if (e.compareTo(node.e) < 0 && node.left == null) {
// 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(root.left, e);
// } else {// e.compareTo(node.e)>0
// add(root.right, e);
// }
// }
// 插入的改进方法
public void add(E e) {
root = add(root, 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);
}
// 查询的递归算法
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 { // e.compareTo(node.e)>0
return contains(node.right, e);
}
}
// 二分搜索树的前序遍历
// 递归的写法
// 中、左、右
public void preOrder() {
preOrder(root);
}
private void preOrder(Node node) {
if (node == null) return;
System.out.println(node.e);
preOrder(node.left);
preOrder(node.right);
}
// 前序遍历的非递归写法
// 利用栈的结构
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));
}
}
// 中序遍历
// 遍历的结果是顺序的
// 左、中、右
public void inOrder() {
inOrder(root);
}
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 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 minmum(){
if (size==0) throw new IllegalArgumentException("BST is empty");
return minmum(root).e;
}
private Node minmum(Node node){
if(node.left==null)
return node;
return minmum(node.left);
}
// 寻找最大值
public E maxmum(){
if (size==0) throw new IllegalArgumentException("BST is empty");
return maxmum(root).e;
}
private Node maxmum(Node node){
if(node.right==null)
return node;
return maxmum(node.right);
}
// 删除最小值并返回
public E removeMin(){
E ret=minmum();
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=maxmum();
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= removeMin(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);
}
else if(e.compareTo(node.e)>0){
node.right=remove(node.right,e);
}
else { // e.compareTo(node.e)=0
// 待删除的节点左子树为空的情况
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 = minmum(node.right);
successor.left = node.left;
successor.right = removeMin(node.right);
node.left = null;
node.right = null;
return successor;
}
return node;
}
@Override
public String toString() {
StringBuilder res = new StringBuilder();
generateBSTString(root, 0, res);
return res.toString();
}
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();
}
}
这里实现的思路比较简单，就当是给我自己一个复习了。大家一起加油！
601
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
