A generic java library for binary tree

A practice java code for generic binary tree java code.

package tree;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Stack;

public class Tree> implements Serializable {
	private static final long serialVersionUID = 1L;
	private Node root;

	public static void main(String[] args) {
		Tree tree = new Tree();
		tree.insert(10);
		tree.insert(7);
		tree.insert(3);
		tree.insert(5);
		tree.insert(4);
		tree.insert(13);
		tree.insert(12);
		tree.insert(14);
		tree.inorder();
		System.out.println();
		tree.preorder();
		System.out.println();
		tree.postorder();
		System.out.println();

		ArrayList list = tree.morrisInorder();
		for (Integer i : list)
			System.out.print(i + " ");
		System.out.println();
		System.out.println(tree.isExist(12));
		tree.deleteByMerg(10);
		tree.preorder();
		tree.deleteByCopy(7);
		System.out.println();
		tree.postorder();

	}

	public Tree() {
		root = null;
	}

	public void visit(Node node) {
		System.out.print(node.ele + " ");
	}

	public void postorder() {
		postorder(root);
	}

	private void postorder(Node node) {
		if (null != node) {
			postorder(node.left);
			postorder(node.right);
			visit(node);
		}
	}

	public void preorder() {
		preorder(root);
	}

	private void preorder(Node node) {
		if (null != node) {
			visit(node);
			preorder(node.left);
			preorder(node.right);
		}
	}

	public void inorder() {
		inorder(root);
	}

	private void inorder(Node node) {
		if (null != node) {
			inorder(node.left);
			visit(node);
			inorder(node.right);
		}
	}

	public void insert(E ele) {
		Node tmp = root, pre = null;
		while (null != tmp) {
			pre = tmp;
			if (tmp.ele.compareTo(ele) < 0)
				tmp = tmp.right;
			else
				tmp = tmp.left;
		}
		if (null == root)
			root = new Node(ele);
		else if (pre.ele.compareTo(ele) < 0)
			pre.right = new Node(ele);
		else if (pre.ele.compareTo(ele) > 0)
			pre.left = new Node(ele);
		else {
			throw new IllegalArgumentException("duplicate element: " + ele);
		}
	}

	public void deleteByCopy(E ele) {
		Node tmp, node, p = root, pre = null;
		while (null != p && !p.ele.equals(ele)) {
			pre = p;
			if (p.ele.compareTo(ele) < 0)
				p = p.right;
			else
				p = p.left;
		}
		node = p;
		if (null != p && p.ele.equals(ele)) {
			Node previous = node;
			for (tmp = node.left; tmp.right != null; tmp = tmp.right){
				previous = tmp;
			}
			node.ele = tmp.ele; // right-most of left child
			if(previous == node)
				tmp = tmp.right;
			else
				previous.right = tmp.left;
			
		} else if (null != root)
			throw new IllegalArgumentException("not exist:" + ele);
		else
			throw new IllegalArgumentException("empty tree");
	}

	public void deleteByMerg(E ele) {
		Node tmp, node, p = root, pre = null;
		while (p != null && !p.ele.equals(ele)) {
			pre = p;
			if (p.ele.compareTo(ele) < 0)
				p = p.right;
			else
				p = p.left;
		}
		node = p;
		// find the element needed to delete
		if (node != null && node.ele.equals(ele)) {
			// only have left child
			if (node.left == null)
				node = node.right;
			// only have right child
			else if (node.right == null)
				node = node.left;
			// have two children, first find the right-most child of left child
			else {
				for (tmp = node.left; tmp.right != null; tmp = tmp.right)
					;
				tmp.right = node.right;
				node = node.left;
			}
			if (root == p)
				root = node;
			else if (pre.left == p)
				pre.left = node;
			else
				pre.right = node;
		} else if (null != root)
			throw new IllegalArgumentException("not exist element: " + ele);
		else
			throw new IllegalArgumentException("empty tree~");

	}

	public boolean isExist(E ele) {
		if (null == root)
			return false;
		Node node = root;
		while (node != null && !node.ele.equals(ele)) {
			if (node.ele.compareTo(ele) < 0)
				node = node.right;
			else
				node = node.left;
		}
		if (node == null)
			return false;
		else
			return true;
	}

	public ArrayList iteratorPostOrder() {
		ArrayList list = new ArrayList();
		if (null == root)
			return list;
		Stack> stack = new Stack>();
		Node p = root, q = root;
		while (null != p) {
			for (; p.left != null; p = p.left)
				stack.push(p);
			while (p != null && (p.right == null || p.right == q)) {
				list.add(p.ele);
				q = p;
				if (stack.isEmpty())
					return list;
				else
					p = stack.pop();
			}
			stack.push(p); // with right node
			p = p.right;
		}

		return list;
	}

	public ArrayList iteratorPreOrder() {
		ArrayList list = new ArrayList();
		if (null == root)
			return list;
		Node p = root;
		Stack> stack = new Stack>();
		stack.push(p);
		while (null != p && !stack.isEmpty()) {
			p = stack.pop();
			list.add(p.ele);
			if (p.right != null)
				stack.push(p.right);
			if (p.left != null)
				stack.push(p.left);
		}
		return list;
	}

	public ArrayList iteratorInorder() {
		ArrayList list = new ArrayList();
		if (null == root) {
			System.err.println("empty tree~");
			return list;
		}
		Node p = root;
		Stack> stack = new Stack>();
		while (null != p) {
			// find the left most node
			while (null != p) {
				if (p.right != null)
					stack.push(p.right);
				stack.push(p);
				p = p.left;
			}
			p = stack.pop(); // left node
			while (!stack.isEmpty() && p.right == null) {
				list.add(p.ele);
				p = stack.pop();
			}
			list.add(p.ele); // get the right node
			if (!stack.isEmpty())
				p = stack.pop();
			else
				p = null;

		}
		return list;
	}

	public ArrayList morrisInorder() {
		ArrayList list = new ArrayList();
		if (null == root) {
			System.err.println("empty tree");
			return list;
		}

		Node p = root, tmp;
		while (null != p) {
			if (null == p.left) {
				list.add(p.ele);
				p = p.right;
			} else {
				tmp = p.left;
				for (; tmp.right != null && tmp.right != p; tmp = tmp.right)
					;
				if (tmp.right == null) {
					tmp.right = p;
					p = p.left;
				} else {
					list.add(p.ele);
					tmp.right = null;
					p = p.right;
				}
			}
		}

		return list;
	}

	private static class Node> {
		E ele;
		Node left, right;

		Node(E ele, Node left, Node right) {
			this.ele = ele;
			this.left = left;
			this.right = right;
		}

		Node(E ele) {
			this(ele, null, null);
		}
	}

}