1.二叉树（BinaryTree）代码
//二叉树
package com.weyan.tree;
import java.util.LinkedList;
import java.util.Queue;
//打印类
import com.weyan.printer.BinaryTreeInfo;
public class BinaryTree<E> implements BinaryTreeInfo {
protected int size;
// 根节点
protected Node<E> root;
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
public void clear() {
root = null;
size = 0;
}
// 前序遍历（递归方法）
public void preorderTraversal() {
preorderTraversal(root);
}
private void preorderTraversal(Node<E> node) {
if (node == null)
return;
System.out.println(node.element);
preorderTraversal(node.left);
preorderTraversal(node.right);
}
// 中序遍历（递归方法）
public void inorderTraversal() {
inorderTraversal(root);
}
private void inorderTraversal(Node<E> node) {
if (node == null)
return;
preorderTraversal(node.left);
System.out.println(node.element);
preorderTraversal(node.right);
}
// 后序遍历（递归方法）
public void postorderTraversal() {
postorderTraversal(root);
}
private void postorderTraversal(Node<E> node) {
if (node == null)
return;
preorderTraversal(node.left);
preorderTraversal(node.right);
System.out.println(node.element);
}
// 层序遍历(通过链表实现)
public void levelorderTraversal() {
if (root == null)
return;
Queue<Node<E>> queue = new LinkedList<>();
// 入队
queue.offer(root);
while (!queue.isEmpty()) {
// 出队
Node<E> node = queue.poll();
System.out.println(node.element);
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
}
/*
* 使用自定义打印器 需要实现以下几个方法
*
*/
@Override
public Object root() {
// TODO Auto-generated method stub
return root;
}
@SuppressWarnings("unchecked")
@Override
public Object left(Object node) {
// TODO Auto-generated method stub
return ((Node<E>) node).left;
}
@SuppressWarnings("unchecked")
@Override
public Object right(Object node) {
// TODO Auto-generated method stub
return ((Node<E>) node).right;
}
@SuppressWarnings("unchecked")
@Override
public Object string(Object node) {
// TODO Auto-generated method stub
// 打印出parent
Node<E> myNode = (Node<E>) node;
String parentString = "null";
if (myNode.parent != null) {
parentString = myNode.parent.element.toString();
}
return myNode.element + "_(" + parentString + ")";
}
// 前驱节点
protected Node<E> predecessor(Node<E> node) {
if (node == null)
return null;
// 前驱节点在左子树当中（left.right.right.........）
Node<E> p = node.left;
if (p != null) {
while (p.right != null) {
p = p.right;
}
return p;
}
// 从父节点、祖父节点当中去找前驱节点
while (node.parent != null && node == node.parent.right) {
node = node.parent;
}
// node.parent == null && node.left == null
return node.parent;
}
// 后继节点
protected Node<E> successor(Node<E> node) {
if (node == null)
return null;
// 前驱节点在左子树当中（right.left.left.........）
Node<E> p = node.right;
if (p != null) {
while (p.left != null) {
p = p.left;
}
return p;
}
// 从父节点、祖父节点当中去找前驱节点
while (node.parent != null && node == node.parent.left) {
node = node.parent;
}
// node.parent == null && node.right == null
return node.parent;
}
/** ---递归写法--- **/
// 二叉树的高度
// public int height() {
// return nodeHeight(root);
// }
// 节点高度
// private int nodeHeight(Node<E> node) {
// if (node == null) return 0;
// return 1 + Math.max(nodeHeight(node.left), nodeHeight(node.right));
// }
/** ---层序遍历写法--- **/
// 二叉树的高度
public int height() {
if (root == null)
return 0;
int height = 0;
// 存储着每一层的元素数量
int levelSize = 1;
Queue<Node<E>> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
Node<E> node = queue.poll();
levelSize--;
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
if (levelSize == 0) {// 意味着即将要访问下一层
levelSize = queue.size();
height++;
}
}
return height;
}
/// 判断一棵树是否为完全二叉树
public boolean isComplete() {
if (root == null)
return false;
Queue<Node<E>> queue = new LinkedList<>();
queue.offer(root);
boolean leaf = false;
while (!queue.isEmpty()) {
Node<E> node = queue.poll();
if (leaf && !node.isLeaf())
return false;
if (node.left != null) {
queue.offer(node.left);
} else if (node.right != null) {
return false;
}
if (node.right != null) {
queue.offer(node.right);
} else {
// 后面遍历的节点都必须是叶子节点
leaf = true;
}
}
return true;
}
protected static class Node<E> {
E element;
// 左子节点
Node<E> left;
// 右子节点
Node<E> right;
// 父节点
Node<E> parent;
// 构造函数
public Node(E element, Node<E> parent) {
this.element = element;
this.parent = parent;
}
// 是否是叶子节点
public boolean isLeaf() {
return left == null && right == null;
}
// 度为2节点
public boolean hasTwoChildrenNode() {
return left != null && right != null;
}
}
}
2.二叉搜索树（BST）代码
package com.weyan.tree;
import java.util.Comparator;
@SuppressWarnings("unchecked")
public class BST<E> extends BinaryTree<E> {
private Comparator<E> comparator;
public void add(E element) {
elementNotNullCheck(element);
// 添加第一个节点
if (root == null) {
root = new Node<>(element, null);
size++;
return;
}
// 添加的不是第一个节点
// 找到父节点
Node<E> parent = root;
Node<E> node = root;
int cmp = 0;
while (node != null) {
parent = node;
cmp = compare(element, node.element);
if (cmp > 0) {
node = node.right;
} else if (cmp < 0) {
node = node.left;
} else {// 相等
node.element = element;
return;
}
}
// 看看插入到父节点的哪个位置
Node<E> newNode = new Node<E>(element, parent);
if (cmp > 0) {
parent.right = newNode;
} else if (cmp < 0) {
parent.left = newNode;
}
size++;
}
public void remove(E element) {
remove(node(element));
}
private void remove(Node<E> node) {
if (node == null) {
return;
}
size--;
// 度为2的节点
if (node.hasTwoChildrenNode()) {
// 找到后继节点
Node<E> s = successor(node);
// 用后继节点的值覆盖度为2的节点的值
node.element = s.element;
// 删除后继节点
node = s;
}
// 删除node节点（node的度必然是1或0）
Node<E> replacement = node.left != null ? node.left : node.right;
if (replacement != null) {// node是度为1节点
// 更改parent
replacement.parent = node.parent;
// 更改parent的left/right的指向
if (node.parent == null) {// node是度为1的节点，并且是根节点
root = replacement;
} else if (node == node.parent.left) {
node.parent.left = replacement;
} else { // node == node.parent.right
node.parent.right = replacement;
}
} else if (node.parent == null) {// node是叶子节点并且是根节点
root = null;
} else {// node是叶子节点，但不是根节点
if (node == node.parent.right) {
node.parent.right = null;
} else {// node == node.parent.left
node.parent.left = null;
}
}
}
// 根据元素查找对应的节点
private Node<E> node(E element) {
Node<E> node = root;
while (node != null) {
int cmp = compare(element, node.element);
if (cmp == 0) {
return node;
}
if (cmp > 0) {
node = node.right;
} else {
node = node.left;
}
}
return null;
}
/// 是否包含一个元素
public boolean contains(E element) {
return node(element) != null;
}
// 比较两个节点,返回值==0代表e1和e2相等;返回值>0代表e1>e2;返回值<0代表e1<e2
private int compare(E e1, E e2) {
if (comparator != null) {
return comparator.compare(e1, e2);
}
return ((Comparable<E>) e1).compareTo(e2);
}
// 判断一个节点是否为空
private void elementNotNullCheck(E element) {
if (element == null) {
throw new IllegalArgumentException("element must not be null");
}
}
}
验证结果
