二叉树的实现

 

树和二叉树的区别：

1. 树中节点的子节点个数没有限制，而二叉树的节点最多为两个
2. 树中的节点无左右之分，而二叉树有左右之分

完全二叉树：

若设二叉树的高度为h，除第h层外，其他各层（1~h-1）的节点数都达到最大个数，第h层有叶子节点，并且叶子节点都是从左到右一次排布

满二叉树：
除了叶子节点外每一个节点都要左右子节点，并且叶子节点都处在最底层的二叉树

二叉树的遍历

1. 先序遍历(根节点-左孩子-右孩子)
2. 中序遍历(左孩子-根节点-右孩子)
3. 后序遍历(左孩子-右孩子-根节点)

二叉树.jpg

图示遍历结果：

先序遍历：A-B-D-G-C-E-F
中序遍历：D-G-B-A-E-C-F
后续遍历：G-D-B-E-F-C-A

首先，定义TreeNode

public class TreeNode {

	// 左节点
	private TreeNode lefTreeNode;
	// 右节点
	private TreeNode rightNode;
	// 数据
	private int value;

	private boolean isDelete;

	public TreeNode getLefTreeNode() {
		return lefTreeNode;
	}

	public void setLefTreeNode(TreeNode lefTreeNode) {
		this.lefTreeNode = lefTreeNode;
	}

	public TreeNode getRightNode() {
		return rightNode;
	}

	public void setRightNode(TreeNode rightNode) {
		this.rightNode = rightNode;
	}

	public int getValue() {
		return value;
	}

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

	public boolean isDelete() {
		return isDelete;
	}

	public void setDelete(boolean isDelete) {
		this.isDelete = isDelete;
	}

	public TreeNode() {
		super();
	}

	public TreeNode(int value) {
		this(null, null, value, false);
	}

	public TreeNode(TreeNode lefTreeNode, TreeNode rightNode, int value, boolean isDelete) {
		super();
		this.lefTreeNode = lefTreeNode;
		this.rightNode = rightNode;
		this.value = value;
		this.isDelete = isDelete;
	}

	@Override
	public String toString() {
		return "TreeNode [lefTreeNode=" + lefTreeNode + ", rightNode=" + rightNode + ", value=" + value + ", isDelete="
				+ isDelete + "]";
	}

}

定义二叉树 BinaryTree ，并定义先序，中序，后序访问方法（利用递归实现）

public class BinaryTree {
	// 根节点
	private TreeNode root;

	public TreeNode getRoot() {
		return root;
	}

	/**
	 * 插入操作
	 * 
	 * @param value
	 */
	public void insert(int value) {

		TreeNode newNode = new TreeNode(value);

		if (root == null) {
			root = newNode;
			root.setLefTreeNode(null);
			root.setRightNode(null);
		} else {

			TreeNode currentNode = root;
			TreeNode parentNode;

			while (true) {

				parentNode = currentNode;
				// 往右放
				if (newNode.getValue() > currentNode.getValue()) {
					currentNode = currentNode.getRightNode();
					if (currentNode == null) {
						parentNode.setRightNode(newNode);
						return;
					}
				} else {
					// 往左放
					currentNode = currentNode.getLefTreeNode();
					if (currentNode == null) {
						parentNode.setLefTreeNode(newNode);
						return;
					}

				}
			}
		}
	}

	/**
	 * 查找
	 * 
	 * @param key
	 * @return
	 */
	public TreeNode find(int key) {

		TreeNode currentNode = root;

		if (currentNode != null) {

			while (currentNode.getValue() != key) {

				if (currentNode.getValue() > key) {
					currentNode = currentNode.getLefTreeNode();
				} else {
					currentNode = currentNode.getRightNode();
				}

				if (currentNode == null) {
					return null;
				}

			}

			if (currentNode.isDelete()) {
				return null;
			} else {
				return currentNode;
			}

		} else {
			return null;
		}

	}

	/**
	 * 中序遍历,递归实现
	 * 
	 * @param treeNode
	 * @author szy
	 */
	public void inOrder(TreeNode treeNode) {
		if (treeNode != null && treeNode.isDelete() == false) {
			inOrder(treeNode.getLefTreeNode());
			System.out.println("--" + treeNode.getValue());
			inOrder(treeNode.getRightNode());
		}
	}


	/**
	 * 先序遍历,递归实现
	 * 
	 * @param treeNode
	 * @author szy
	 */
	public void preOrder(TreeNode treeNode) {
		if (treeNode != null && treeNode.isDelete() == false) {
			System.out.println("--" + treeNode.getValue());
			preOrder(treeNode.getLefTreeNode());
			preOrder(treeNode.getRightNode());
		}
	}

	/**
	 * 后续遍历，递归实现
	 * 
	 * @param treeNode
	 * @author szy
	 */
	public void posOrder(TreeNode treeNode) {
		if (treeNode != null && treeNode.isDelete() == false) {
			System.out.println("--" + treeNode.getValue());
			preOrder(treeNode.getRightNode());
			preOrder(treeNode.getLefTreeNode());
		}
	}
}

参考链接：https://www.jianshu.com/p/c1ba0992a35e