Java实现二叉树、 双链表

public class MyDoubleLink implements Iterable{
	private class Node {
		Node	next;	// 下一个节点
		Node	prev;	// 前一个节点
		Object	data;	// 数据
	}

	private Node	head;	// 头节点
	private Node	rear;	// 尾节点

	private int modCount = 0;
	/**
	 * 从链表的后面添加数据
	 * 
	 * @param data
	 */
	public void add(Object data) {
		Node node = new Node();// 创建新的节点
		node.data = data;// 把数据放到节点中
		// 把节点链接到链表中

		// 是否有头节点
		if (head == null) {
			// 没有头节点
			head = node; // 头节点
			rear = node; // 尾节点
		} else {
			// 有头点节点
			// 从尾部添加数据

			rear.next = node;
			node.prev = rear;

			rear = node;// 新的尾节点
		}
		modCount++;
	}

	/**
	 * 删除数据
	 * 
	 * @param data
	 */
	public void remove(Object data) {
		// 1. 判断数据是否存在
		Node node = findData(data);
		if (node != null) {
			// 数据存在
			// 删除节点

			
			if (node == head && node == rear) {
				// 1. node 即是头节点又是尾节点
				head = null;
				rear = null;// 只有一个数据
			} else if (node == head) {
				// 2. node 是头节点 后面肯定有节点
				head = head.next;//第二节点成为头节点
				head.prev = null;//头节点前面没有节点
			} else if (node == rear) {
				// 3. node 是尾节点 前面肯定有节点
				rear = rear.prev;
				rear.next = null;//尾节点后面没有节点
			} else {
				// 4. node 中间节点 前后都有节点
				node.prev.next = node.next;
				node.next.prev = node.prev;
			}
			modCount++;
		}
	}

	/**
	 * 修改数据
	 * 
	 * @param oldData
	 * @param newData
	 */
	public void update(Object oldData, Object newData) {
		Node node = findData(oldData);
		if (node != null) {
			node.data = newData;
		}
	}

	/**
	 * 查找数据所在的节点
	 * 
	 * @param data
	 * @return null 数据不存在
	 */
	private Node findData(Object data) {
		Node temp = head;
		while (temp != null) {
			// 判断数据
			if (temp.data.equals(data)
					&& temp.data.hashCode() == data.hashCode()) {
				break;// 找到数据
			} else {
				// 继续找下一个
				temp = temp.next;
			}
		}

		return temp;
	}

	/**
	 * 容器中是否包含数据
	 * 
	 * @param data
	 * @return
	 */
	public boolean contains(Object data) {
		Node node = findData(data);

		return node != null;// 数据是否存在
	}

	@Override
	public String toString() {
		StringBuilder mess = new StringBuilder("[");
		// 遍历所有节点
		Node temp = head;
		while (temp != null) {
			if (temp == rear) {
				// 最后一个节点
				mess.append(temp.data + "]");
			} else {
				mess.append(temp.data + ", ");
			}

			// 继续找下一个节点
			temp = temp.next;

		}

		return mess + "";// mess.toString()
	}

	@Override
	public Iterator iterator() {
		// TODO Auto-generated method stub
		return new Ite();
	}
	
	private class Ite implements Iterator{
		private int currentMode = modCount;
		private Node node = head;//从头节点开始遍历 
		@Override
		public boolean hasNext() {
			if (node != null)
				return true;
			else
				return false;
		}

		@Override
		public Object next() {
			
			// 判断容器是否修改了
			if (modCount != currentMode) {
				//容器被修改了
				throw new ConcurrentModificationException();
			}
			Object data = node.data;
			//下一个位置
			node = node.next;
			return data;
		}

		@Override
		public void remove() {
			// TODO Auto-generated method stub
			
		}
		
	}
}

public class MyTree {
	// 节点
	private class Node {
		Node	parrent;
		Node	left;
		Node	right;
		Object	data;
	}

	private Node	root;	// 树根

	/**
	 * 分裂节点
	 * 
	 * @param node
	 *            删除的节点
	 * @return
	 */
	private Node split(Node node) {
		// 保留左儿子
		Node left = node.left;

		// 把右儿子添加到左儿子最右边
		Node parrent = findParrent(node.right.data, left);

		// 安排删除节点右儿子的归属
		node.right.parrent = parrent;
		parrent.right = node.right;
		return left;
	}

	/**
	 * 删除数据
	 * 
	 * @param data
	 */
	public void remove(Object data) {

		// 查找数据所在的节点
		Node node = findData(data);
		if (node == null)
			return;

		if (node == root) {// 1. root

			if (node.left == null && node.right == null) {
				// 1. 没有子节点, 树中只有一个数据
				root = null;
			} else if (node.right == null) {
				// 2. 只有left节点
				root = root.left;// left成了根节点
				root.parrent = null;// 根节点没有父节点

			} else if (node.left == null) {
				// 3. 只有right节点
				root = root.right;// right成了根节点
				root.parrent = null;// 根节点没有父节点

			} else {
				// 4. 两个子节点
				Node left = split(node);
				root = left;
				root.parrent = null;

			}

		} else {// 2. 非root节点
			Node parrent = node.parrent;
			if (node.left == null && node.right == null) {
				// 1. 没有子节点

				if (compare(parrent.data, node.data)) {
					parrent.left = null;
				} else {
					parrent.right = null;
				}

			} else if (node.right == null) {
				// 2. 只有left节点
				node.left.parrent = node.parrent;

				if (compare(parrent.data, node.left.data)) {
					// left
					parrent.left = node.left;
				} else {
					// right
					parrent.right = node.left;

				}
			} else if (node.left == null) {
				// 3. 只有right节点
				node.right.parrent = node.parrent;

				if (compare(parrent.data, node.right.data)) {
					// left
					parrent.left = node.right;
				} else {
					// right
					parrent.right = node.right;

				}
			} else {
				// 4. 两个子节点
				Node left = split(node);
				//比较父节点的大小
				if (compare(parrent.data,left.data)) {
					//left
					parrent.left = left;
				} else {
					//right
					parrent.right = left;
				}
			}
		}

	}

	// 1. 添加数据
	public void add(Object data) {
		// 判断是否存在
		Node node = findData(data);
		if (node != null) {
			// 数据存在
			return;
		}

		Node newNode = new Node();// 创建的新节点
		newNode.data = data;
		// 添加数据
		if (root == null) {
			// 没有数据
			root = newNode;
		} else {

			// 添加数据
			// 找父节点
			Node parrent = findParrent(data, root);

			// 添加
			newNode.parrent = parrent;
			// 判断left or right
			if (compare(data, parrent.data)) {
				// right
				parrent.right = newNode;
			} else {
				// left
				parrent.left = newNode;
			}
		}
	}

	public void print() {
		see(root);
	}

	private void see(Node node) {
		if (node != null) {
			// 中序遍历二叉树
			see(node.left);
			System.out.println(node.data);
			see(node.right);
		}
	}

	private Node findParrent(Object data, Node addNodePosition) {
		Node node = addNodePosition;
		Node parrent = node;// 父节点

		while (node != null) {
			parrent = node;
			// 比较大小
			if (compare(node.data, data)) {
				// left
				node = node.left;
			} else {
				// right
				node = node.right;
			}
		}

		return parrent;
	}

	/**
	 * @param o1
	 * @param o2
	 * @return true o1 > o2 false o1 < o2
	 */
	private boolean compare(Object o1, Object o2) {
		// 判断o1 是否具有比较器
		Comparable c1 = null;
		Comparable c2 = null;
		if (o1 instanceof Comparable) {
			// 有
			c1 = (Comparable) o1;
			c2 = (Comparable) o2;
		} else {
			// 没有 toString 比较
			c1 = o1.toString();
			c2 = o2.toString();

		}

		if (c1.compareTo(c2) > 0) {
			return true;
		}
		return false;
	}

	/**
	 * 查找数据所在的节点
	 * 
	 * @param data
	 * @return
	 */
	private Node findData(Object data) {
		Node temp = root;// 从根节点遍历
		while (temp != null) {
			// 判断值是否一致
			if (temp.data.equals(data)
					&& temp.data.hashCode() == data.hashCode()) {
				// 一致 找到数据 break
				break;
			} else {
				// 不一致
				// 判断比较大小
				if (compare(temp.data, data)) {
					// 如果data 比当前节点数据小 从left
					temp = temp.left;
				} else {
					// 如果data 比当前节点数据大 从right
					temp = temp.right;
				}

			}

		}
		return temp;
	}

}