底层源码实现二叉树【自定义二叉树（二叉排序树)】

 

public class MyBinarySortTree<E>{
	/**根节点*/
	Node<E> root;//null
	/**统计节点个数*/
	int size;//0
	
	/**
	 * 根据传入的元素内容构建一个新节点,
	 * 并插入到二叉树中
	 * @param e	节点内容
	 */
	public void insert(E e) {
		//根据节点内容构建一个新节点
		Node<E> newNode = new Node<E>(e);
		if(root==null) {//空二叉树
			root = newNode;
		}else {//非空二叉树
			//当前节点
			Node<E> current = root;
			//当前节点的父节点
			Node<E> parent;
			while(true) {//查找插入的位置
				parent = current;
				//插入的节点内容
				Comparable<E> c1 = (Comparable<E>)e;
				//被比较的节点内容
				Comparable<E> c2 = (Comparable<E>)current.value;
				//插入节点的内容小于当前节点内容,插入到左边
				if(c1.compareTo((E)c2)<0) {
					current = current.left;
					if(current==null) {
						parent.setLeft(newNode);
						return;
					}
				}else {//插入节点的内容大于当前节点内容,插入到右边
					current = current.right;
					if(current==null) {
						parent.setRight(newNode);
						return;
					}
				}
			}
		}
		size++;
	}
	
	/**获取二叉树中节点个数*/
	public int size() {
		return size;
	}
	
	/**前序遍历:根->左->右*/
	public void preOrder(Node<E> node) {
		if(node==null) {
			return;
		}
		System.out.print(node.getValue()+"  ");
		preOrder(node.getLeft());
		preOrder(node.getRight());
	}
	
	/**中序遍历:左->根->右*/
	public void middleOrder(Node<E> node) {
		if(node==null) {
			return;
		}
		middleOrder(node.getLeft());
		System.out.print(node.getValue()+"  ");
		middleOrder(node.getRight());
	}

	/**后序遍历:左->右->根*/
	public void lastOrder(Node<E> node) {
		if(node==null) {
			return;
		}
		lastOrder(node.getLeft());
		lastOrder(node.getRight());
		System.out.print(node.getValue()+"  ");
	}
	
	/**根据内容查找一个Node节点对象*/
	@SuppressWarnings("unchecked")
	public Node<E> nodeOf(E e){
		int count=0;
		Node<E> current = root;
		//要查找的节点值
		Comparable<E> c1 = (Comparable<E>)e;
		//当前节点值
		Comparable<E> c2 = (Comparable<E>)current.getValue();
		while(c1.compareTo((E)c2)!=0) {
			count++;
			c2 = (Comparable<E>)current.getValue();
			if(c1.compareTo((E)c2)>0) {
				current = current.getRight();
			}else if(c1.compareTo((E)c2)<0){
				current = current.getLeft();
			}else {
				System.out.println("查找次数"+count);
				return current;
			}
			if(current==null) {//没有该内容的节点
				return null;
			}
		}
		return current;
	}
	
	/**查找最小节点*/
	public Node<E> findMinNode() {
		if(root==null)return null;
		Node<E> current=root;
		while(current.getLeft()!=null) {
			current=current.getLeft();
		}
		return current;
	}
	/**查找最大节点*/
	public Node<E> findMaxNode() {
		if(root==null)return null;
		Node<E> current=root;
		while(current.getRight()!=null) {
			current=current.getRight();
		}
		return current;
	}
	
	/**二叉树上的节点*/
	static class Node<E>{
		/**节点内容*/
		E value;
		/**左子节点*/
		Node<E> left;
		/**右子节点*/
		Node<E> right;
		
		public Node(E value) {
			this.value = value;
		}

		public Node(E value, Node<E> left, Node<E> right) {
			super();
			this.value = value;
			this.left = left;
			this.right = right;
		}

		public E getValue() {
			return value;
		}

		public void setValue(E value) {
			this.value = value;
		}

		public Node<E> getLeft() {
			return left;
		}

		public void setLeft(Node<E> left) {
			this.left = left;
		}

		public Node<E> getRight() {
			return right;
		}

		public void setRight(Node<E> right) {
			this.right = right;
		}

		@Override
		public String toString() {
			return "Node [value=" + value + "]";
		}
	}
	
	public static void main(String[] args) {
		//构建一个二叉树
		MyBinarySortTree<Integer> tree = new MyBinarySortTree<>();
		tree.insert(50);
		tree.insert(30);
		tree.insert(80);
		tree.insert(15);
		tree.insert(45);
		tree.insert(58);
		tree.insert(38);
		
		//根据内容查找结点
		Node<Integer> node = tree.nodeOf(38);
		System.out.println(node);
		
		//前序遍历
		System.out.println("-----前序遍历-----");
		tree.preOrder(tree.nodeOf(50));
		//中序遍历
		System.out.println();
		System.out.println("-----中序遍历-----");
		tree.middleOrder(tree.nodeOf(50));
		//后序遍历
		System.out.println();
		System.out.println("-----后序遍历-----");
		tree.lastOrder(tree.nodeOf(50));
		
		System.out.println("\n--------------");
		System.out.println("最小节点："+tree.findMinNode());
		System.out.println("--------------");
		System.out.println("最大节点："+tree.findMaxNode());
	}
}

1>插入节点
 * 2>前序遍历
 * 3>中序遍历
 * 4>后序遍历
 * 5>查找最小节点
 * 6>查找最大节点
 * 7>根据内容移除一个节点