排序二叉树的实现 Java版

排序二叉树的接口

package tree;

/**
 * 二叉排序树
 * 
 * @author liangguojun
 * 
 * @param <T>
 *            数据类型
 */
public interface SortTree<T extends Comparable<T>> {
	// 降序
	public static final int DESC_DATA = 0;
	// 升序
	public static final int ASC_DATA = 1;

	/**
	 * 清空排序二叉树
	 */
	public void clear();

	/**
	 * 返回排序二叉树的深度
	 * 
	 * @return 返回排序二叉树的深度
	 */
	public int getDept();

	/**
	 * 判断二叉排序树是否为空
	 * 
	 * @return 若二叉树为空返回true，否则返回false
	 */
	public boolean isEmpty();

	/**
	 * 返回二叉树的长度
	 * 
	 * @return 返回排序二叉树的长度
	 */
	public int getLength();

	/**
	 * 插入节点
	 * 
	 * @param data
	 *            插入节点的数据
	 * @return 成功插入则返回true ， 否则返回false
	 */
	public boolean insert(T data);

	/**
	 * 查询数据data
	 * 
	 * @param data
	 *            数据
	 * @return 成功查找则返回true，否则返回false
	 */
	public boolean search(T data);

	/**
	 * 遍历二叉树，根据参数是升序还是降序打印所有元素
	 * 
	 * @param order_by
	 *            升序或降序的控制单位
	 */
	public void view(int order_by);

	/**
	 * 删除数据元素为data的节点
	 * 
	 * @param data
	 *            数据元素
	 * @return 成功删除则返回被删除的元素
	 */
	public T deleteData(T data);

	/**
	 * 修改二叉树的节点数据
	 * 
	 * @param data
	 *            替换的数据
	 * @param move
	 *            将要被替换 的数据
	 * @return 成功替换则返回true，否则返回false
	 */
	public boolean updateData(T data, T move);
}

排序二叉树的实现，省略节点类

package tree;

/**
 * 排序二叉树
 * @author liangguojun
 *
 * @param <T>
 */
public class SortBirTree<T extends Comparable<T>> implements SortTree<T> {
	private TNode<T> root;

	public SortBirTree() {
		root = null;
	}

	@Override
	public void clear() {
		root = null;
	}

	/**
	 * 私有方法，此方法是计算二叉树的深度
	 * 
	 * @param cur
	 *            参数是二叉树的根节点
	 * @return 返回排序二叉树的深度
	 */
	private int getDept(TNode<T> cur) {
		if (cur != null) {
			int ldept = 0;
			int rdept = 0;
			// 递归遍历左子树和右子树的深度
			ldept = getDept(cur.getlChild()) + 1;
			rdept = getDept(cur.getrChild()) + 1;
			return ldept > rdept ? ldept : rdept;
		}
		return 0;
	}

	@Override
	public int getDept() {
		return getDept(root);
	}

	@Override
	public boolean isEmpty() {
		if (root == null) {
			return true;
		}
		return false;
	}

	/**
	 * 求cur的子树的长度
	 * 
	 * @param cur
	 *            子树
	 * @return 返回cur子树的所有节点的个数，不包括cur
	 */
	private int getLength(TNode<T> cur) {
		if (cur != null) {
			int lLength = 0;
			int rLength = 0;
			// 递归调用方法，遍历左右子树，求出各子树的节点数
			if (cur.getlChild() != null)
				lLength = getLength(cur.getlChild()) + 1;
			if (cur.getrChild() != null) {
				rLength = getLength(cur.getrChild()) + 1;
			}
			return lLength + rLength;
		}
		return 0;
	}

	@Override
	public int getLength() {
		if (root != null)
			return getLength(root) + 1;
		return 0;
	}

	private boolean insert(T data, TNode<T> cur) {
		if (data != null) {
			if (root == null) {
				root = new TNode<T>(data);
				return true;
			}
			// 假如插入的数据比当前节点大，且cur右节点为空，则插入有节点
			if (cur.getData().compareTo(data) < 0) {
				if (cur.getrChild() == null) {
					cur.setrChild(new TNode<T>(data));
					return true;
				}
				// cur右孩子不为空，则继续调用插入方法
				else
					return insert(data, cur.getrChild());
			} else {
				// 假如插入的数据比当前节点的小，且cur左孩子为空，则插入节点
				if (cur.getData().compareTo(data) > 0) {
					if (cur.getlChild() == null) {
						cur.setlChild(new TNode<>(data));
						return true;
					} else
						return insert(data, cur.getlChild());
				}
			}
		}
		return false;
	}

	@Override
	public boolean insert(T data) {
		return insert(data, root);
	}

	private boolean search(T data, TNode<T> cur) {
		if (data != null && cur != null) {
			// 假如查找的数据比cur小，则去左孩子继续查询
			if (cur.getData().compareTo(data) > 0) {
				return search(data, cur.getlChild());
			} else if (cur.getData().compareTo(data) < 0) {
				// 假如查找的数据比cur 大，则去右孩子继续查询
				return search(data, cur.getrChild());
			} else if (cur.getData().compareTo(data) == 0)
				// 查找成功
				return true;
		}
		return false;
	}

	@Override
	public boolean search(T data) {
		return search(data, root);
	}

	/**
	 * 升序排序遍历二叉树
	 * 
	 * @param cur
	 *            子树的根节点
	 */
	private void viewASC(TNode<T> cur) {
		if (cur != null) {
			viewASC(cur.getlChild());
			System.out.print(cur.getData() + " ");
			viewASC(cur.getrChild());
		}
	}

	private void viewDESC(TNode<T> cur) {
		if (cur != null) {
			viewDESC(cur.getrChild());
			System.out.print(cur.getData() + " ");
			viewDESC(cur.getlChild());
		}
	}

	@Override
	public void view(int order_by) {

		if (order_by == DESC_DATA) {

			viewDESC(root);
			System.out.println();
		} else if (order_by == ASC_DATA) {
			viewASC(root);
			System.out.println();
		} else {
			System.out.println("传入的参数不正确");
		}
	}

	/**
	 * 删除指定的节点
	 * 
	 * @param cur
	 *            被删除的节点
	 * @param parent
	 *            被删除节点的双亲节点
	 * @return 成功删除则返回true，否则返回false
	 */
	private T delete(TNode<T> cur, TNode<T> parent) {
		if (cur != null) {
			if (cur.getlChild() == null) {
				// 判断是否为根节点
				if (parent != null) {
					if (parent.getlChild() == cur) {
						parent.setlChild(cur.getrChild());
					} else if (parent.getrChild() == cur) {
						parent.setrChild(cur.getrChild());
					}
				} else {
					// 如果删除的是根节点，则为根节点赋值
					root = cur.getrChild();
				}
			} else if (cur.getrChild() == null) {
				// 判断是否为根节点
				if (parent != null) {
					if (parent.getlChild() == cur) {
						parent.setlChild(cur.getlChild());
					} else if (parent.getrChild() == cur) {
						parent.setrChild(cur.getlChild());
					}
				} else {
					// 如果删除的是根节点，则为根节点赋值
					root = cur.getlChild();
				}
			}
			// 左右孩子都不为空
			else {
				TNode<T> s = cur;
				TNode<T> tmp = cur.getlChild();
				while (tmp.getrChild() != null) {
					s = tmp;
					tmp = tmp.getrChild();
				}
				// 把tmp节点拿去替换被删除的节点，修改tmp的双亲的子树
				s.setrChild(tmp.getlChild());

				// 判断删除的cur是否为根节点
				if (parent != null) {
					if (parent.getlChild() == cur) {
						parent.setlChild(tmp);
						tmp.setlChild(cur.getlChild());
						tmp.setrChild(cur.getrChild());
					} else if (parent.getrChild() == cur) {
						parent.setrChild(tmp);
						tmp.setlChild(cur.getlChild());
						tmp.setrChild(cur.getrChild());
					}
				} else {
					root = tmp;
					tmp.setlChild(cur.getlChild());
					tmp.setrChild(cur.getrChild());
				}
			}
			return cur.getData();
		}
		return null;
	}

	/**
	 * 删除数据元素data
	 * 
	 * @param data
	 *            被删除的数据元素
	 * @param cur
	 *            指定所要删除的元素所在的子树
	 * @param parent
	 *            子树的双亲节点
	 * @return 成功三楚则返回true，否则返回false
	 */
	private T deleteData(T data, TNode<T> cur, TNode<T> parent) {
		if (data != null && cur != null) {
			if (data.compareTo(cur.getData()) > 0) {
				return deleteData(data, cur.getrChild(), cur);
			} else if (data.compareTo(cur.getData()) < 0) {
				return deleteData(data, cur.getlChild(), cur);
			} else
				return delete(cur, parent);
		}
		return null;
	}

	@Override
	public T deleteData(T data) {
		// TODO
		return deleteData(data, root, null);
	}

	/**
	 * 把二叉树中数据为move的节点数据修改成data
	 * 
	 * @param data
	 *            替换的数据
	 * @param move
	 *            别替换的数据
	 * @param cur
	 *            二叉树节点
	 * @return 成功替换则返回true，否则返回false
	 */
	private boolean updateData(T data, T move, TNode<T> cur) {
		if (data != null && cur != null) {
			deleteData(move);
			return insert(data);

		}
		return false;
	}

	@Override
	public boolean updateData(T data, T move) {
		return updateData(data, move, root);
	}

	public TNode<T> getRoot() {
		return root;
	}

	public void setRoot(TNode<T> root) {
		this.root = root;
	}

	public static void main(String[] args) {
		String[] a = { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J" };
		SortBirTree<String> test = new SortBirTree<>();
		for (int i = 0; i < a.length; i++) {
			test.insert(a[i]);
		}
		// test.insert(38);
		test.view(ASC_DATA);
		System.out.println("排序二叉树的深度 " + test.getDept());
		System.out.println("排序二叉树的长度为：" + test.getLength());
		// test.clear();
		// System.out.println("二叉树是否为空？：" + test.isEmpty());
		// System.out.println("删除47:" + test.deleteData(47));
		// test.view(SortBirTree.ASC_DATA);
		// test.insert(20);
		// test.view(ASC_DATA);
		// System.out.println("修改88的值：" + test.updateData(56, 88));
		// test.deleteData(88);
		// test.view(ASC_DATA);
		// System.out.println("排序二叉树的深度 " + test.getDept());
		// System.out.println("查：" + test.search(62));
	}
}