二叉树

二叉树

二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个结点最多只能有两棵子树，且有左右之分。
二叉树是n个有限元素的集合，该集合或者为空、或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成，是有序树。当集合为空时，称该二叉树为空二叉树。在二叉树中，一个元素也称作一个结点。

二叉树的种类

斜树：所有结点都只有左子树或者右子树。

满二叉树：所有的分支结点都具有左右结点。

完全二叉树：若设二叉树的深度为 h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。

二叉树的性质

二叉树第 i 层上的结点数目最多为 2^(i-1) (i≥1)
深度为 h 的二叉树至多有 2^h-1 个结点(h≥1)
包含 n 个结点的二叉树的高度至少为 log2 (n+1)
在任意一棵二叉树中，若终端结点的个数为 n0，度为 2 的结点数为 n2，则 n0=n2+1

二叉树的遍历方式

二叉树的遍历方式，一般分为先序遍历，中序遍历，后序遍历。
• 先序遍历
o 先访问根节点，然后访问左节点，最后访问右节点(根->左->右)
• 中序遍历
o 先访问左节点，然后访问根节点，最后访问右节点(左->根->右)
• 后序遍历
o 先访问左节点，然后访问右节点，最后访问根节点(左->右->根)

如上图：
先序遍历：1-2-4-5-3-6-7
中序遍历：4-2-5-1-6-3-7
后序遍历：4-5-2-6-7-3-1

建立二叉树：

public class TreeNode{
	private TreeNode leftTreeNode;
	private TreeNode rightTreeNode;
	private String value;
	public TreeNode getLeftTreeNode(){
		return leftTreeNode;
	}
	public void setLeftTreeNode(TreeNode leftTreeNode){
		this.leftTreeNode = leftTreeNode;
	}
	public TreeNode getRightTreeNode(){
		return rightTreeNode;
	}
	public void setRightTreeNode(TreeNode rightTreeNode){
		this.rightTreeNode = rightTreeNode;
	}
	public String getValue(){
		return value;
	}
	public void setValue(String value){
		this.value = value;
	}
	public TreeNode(String value){
		super();
		this.value = value;
	}
	@Override
	public String toString() {
    	return "TreeNode [leftTreeNode=" + leftTreeNode + ", 
    	rightTreeNode=" + rightTreeNode + ", value=" + value + "]";
	} 
}

插入：

public class BinaryTree{
	private TreeNode root;
	public TreeNode getRoot(){
		return root;
	}
	public TreeNode getRoot() {
    	return root;
	}
	public void insert(String value) {
    	TreeNode newNode = new TreeNode(value);
    	if (root == null) {
       	 	root = newNode;
        	root.setLeftTreeNode(null);
        	root.setRightTreeNode(null);
    	} else {
        	TreeNode currentNode = root;
        	TreeNode parentNode;
        // 有孩子继续循环，一直循环到最后一个节点 和插入的节点比较 大的放到右节点，小于放到左节点
        	while (true) {
            	parentNode = currentNode;
            // 往右放
            	if (Integer.valueOf(newNode.getValue()) > Integer.valueOf(currentNode.getValue())) {
                	currentNode = currentNode.getRightTreeNode();
                	if (currentNode == null) {
                    	parentNode.setRightTreeNode(newNode);
                    	return;
                	}
            	} else {
                // 往左放
                	currentNode = currentNode.getLeftTreeNode();
                	if (currentNode == null) {
                    	parentNode.setLeftTreeNode(newNode);
                    	return;
                	}
            	}
        	}
    	}
	}
}

遍历：

//先序遍历
public void beforeOrder(TreeNode treeNode){
	if(treeNode != null){
		System.out.println(" "+treeNode.getValue()+" ");
		beforeOrder(treeNode.getLeftTreeNode());
		beforeOrder(treeNode.getRightTreeNode());
	}
}

//中序遍历
public void inOrder(TreeNode treeNode){
	if(treeNode != null){
		inOrder(treeNode.getLeftTreeNode());
		System.out.println(" "+treeNode.getValue()+" ");
		inOrder(treeNode.getRightTreeNode());
	}
}

//后序遍历
publci void afterOrder(TreeNode treeNdoe){
	if(treeNdoe != null){
		afterOrder(treeNode.getLeftTreeNode());
		afterOrder(treeNode.getRightTreeNode());
		System.out.println(" "+treeNode.getValue()+" ");
	}
}