1.. 二叉树
-
跟链表一样，二叉树也是一种动态数据结构，即，不需要在创建时指定大小。
-
跟链表不同的是，二叉树中的每个节点，除了要存放元素e，它还有两个指向其它节点的引用，分别用Node left和Node right来表示。
-
类似的，如果每个节点中有3个指向其它节点的引用，就称其为"三叉树"...
-
二叉树具有唯一的根节点。
-
二叉树中每个节点最多指向其它的两个节点，我们称这两个节点为"左孩子"和"右孩子"，即每个节点最多有两个孩子。
-
一个孩子都没有的节点，称之为"叶子节点"。
-
二叉树的每个节点，最多只能有一个父亲节点，没有父亲节点的节点就是"根节点"。
-
二叉树的形象化描述如下图：
- 二叉树具有天然的递归结构。
- 每个节点的"左子树"也是一棵二叉树，每个节点的"右子树"也是一棵二叉树。
- 二叉树不一定是"满的"，即，某些节点可能只有一个子节点；更极端一点，整棵二叉树可以仅有一个节点；在极端一点，整棵二叉树可以一个节点都没有；
3.. 实现二分搜索树
- 二分搜索树的构造函数、getSize方法、isEmpty方法及add方法的实现逻辑如下：
-
public class BST<E extends Comparable> { 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; } // 实现size方法 public int size() { return size; } // 实现isEmpty方法 public boolean isEmpty() { return size == 0; } // 实现add方法 public void add(E 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; } }
- 二分搜索树的contains方法实现逻辑如下：
-
// 实现contains方法，判断二分搜索树中是否包含元素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 { return contains(node.right, e); } }
- 二分搜索树的遍历操作，遍历操作就是把所有节点都访问一遍
- 前序遍历的业务逻辑如下：
-
//二分搜索树的前序遍历 public void preOder() { preOrder(root); } private void preOrder(Node node) { if (node == null) { return; } System.out.print(node.e); 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.print(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.print(node.e); }
- 简单测试如下：
-
public class Main { public static void main(String[] args) { BST<Integer> bst = new BST<>(); int[] nums = {5, 3, 6, 8, 4, 2}; for (int num : nums) { // 测试add方法 bst.add(num); } // 测试前序遍历 bst.preOrder(); System.out.println(); // 测试中序遍历 bst.inOrder(); System.out.println(); // 测试后序遍历 bst.postOrder(); } }
- 输出结果：
-
532468 234568 243865
- 前序遍历是最自然的遍历方式，也是最常用的遍历方式；中序遍历的结果是按从小到大的顺序的排列的；后序遍历可以用于为二分搜索树释放内存。
- 利用"栈"实现二分搜索树的非递归前序遍历
-
// 二分搜索树的非递归前序遍历 public void preOrderNR() { Stack<Node> stack = new Stack<>(); stack.push(root); while (!stack.isEmpty()) { Node cur = stack.pop(); System.out.print(cur.e); if (cur.right != null) { stack.push(cur.right); } if (cur.left != null) { stack.push(cur.left); } } }
- 二分搜索树的非递归实现比递归实现更加复杂。
- 二分搜索树的前序、中序和后续遍历都属于"深度优先"算法。
- 二分搜索树的"层序遍历"属于"广度优先"算法。
- 利用"队列"实现二分搜索树的"层序遍历"
-
// 二分搜索树的层序遍历 public void levelOrder() { Queue<Node> q = new LinkedList<>(); q.add(root); while (!q.isEmpty()) { Node cur = q.remove(); System.out.print(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; } // 返回以node为根的二分搜索树的最小元素所在节点 private Node minimum(Node node) { if (node.left == null) { return node; } return minimum(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 maximum(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) { 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 { // 待删除节点左子树为空的情况 if (node.left == null) { Node rightNode = node.right; node.right = null; size--; return rightNode; // 待删除节点右子树为空的情况 } else if (node.right == null) { Node leftNode = node.left; node.left = null; size--; return leftNode; // 待删除节点左右子树均不为空 // 找到比待删除节点大的最小节点，即待删除节点右子树的最小节点 // 用这个节点顶替待删除节点 } else { Node successor = minimum(node.right); successor.right = removeMin(node.right); //这里进行了size--操作 successor.left = node.left; node.left = null; node.right = null; return successor; } } }