目录
1、为什么要研究树结构？
将数据使用树结构存储后，出奇地高效
二分搜索树（Binary Search Tree）
平衡二叉树：AVL；红黑树
堆；并查集
线段树；Trie（字典树，前缀树）
2、二分搜索树
2.1、二叉树
二叉树具有唯一根节点，在图中，28就是根节点
class Node{
E e;
Node left; //左孩子
Node right; //右孩子
}最下面的没有孩子节点的节点被称为叶子节点
二叉树中每个节点最多有两个孩子
二叉树中每个节点最多有一个父亲
二叉树具有天然递归结构
2.2、二分搜索树
2.2.1、二分搜索树添加新元素
- 我们的二分搜索树不包含重复元素
- 如果向包含重复元素的话，只需要定义：左子树小于等于节点；或者右子树大于等于节点。
- 二分搜索树添加元素的非递归写法，和链表很像
3、遍历操作
3.1、什么是遍历操作
- 遍历操作就是把所有节点都访问一遍；
- 访问的原因和业务有关；
- 在线性结构下，遍历是很容易的；
- 在树形结构下，要稍微复杂一点；
3.2、二分搜索树的递归操作
4、BST.java
/**
* 二分搜索树（Binary Search Tree）
* 它并非支持所有类型，所支持的类型必须具有可比性，所以要 extends Comparable
*
* @param <E>
*/
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;
}
//向二分搜索树中添加新的元素e
public void add(E e) {
// if (root == null) {
// root = new Node(e);
// size++;
// } else {
// add(root, e);
// }
root = add(root, 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;
}
/**
* 向以node为根的二分搜索树中插入元素E，递归算法
* <p>
* 而对于递归算法来说，要看两部分：
* 第一，递归终止的条件
* 第二，递归组成的逻辑
*/
private void add1(Node node, E e) {
// 第一，递归终止的条件
// 但是如下代码过于臃肿
if (e.equals(node.e))
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(node.left, e);
else
add(node.right, 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)
return contains(node.left, e);
else // e.compareTo(node.e) > 0
return contains(node.right, e);
}
// 二分搜索树的前序遍历
public void preOrder() {
preOrder(root);
}
// 前序遍历以node为根的二分搜索树，递归算法
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);
}
// 中序遍历以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);
}
// 后序遍历以node为根的二分搜索树，递归算法
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;
}
// 返回以node 为根的二分搜索树的最小值所在的点
private Node minmum(Node node) {
if (node.left == null)
return node;
return minmum(node.left);
}
// 寻找二分搜索树的最大元素
public E maximum() {
if (size == 0)
throw new IllegalArgumentException("BST is empty!");
return maximum(root).e;
}
// 返回以node 为根的二分搜索树的最大值所在的点
private Node maximum(Node node) {
if (node.right == null)
return node;
return minmum(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 = 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;
} else 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 = minmum(node.right);
successor.right = removeMin(node.right);
successor.left = node.left;
// 让node节点与二分搜索树脱离关系
node.left = node.right = null;
return successor;
}
}
@Override
public String toString() {
StringBuilder res = new StringBuilder();
generateBSTString(root, 0, res);
return res.toString();
}
/**
* 生成以node为根节点，深度为depth的描述二叉树的字符串
*
* @param node 根节点
* @param depth 深度
* @param res 返回结果
*/
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();
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
