树与二叉树(遍历)

一、树

树结构是一种非常重要的非线性数据结构，该结构中的一个数据元素可以有两个或者两个以上的直接后继元素。

1、树的定义

树是由 n(n>=0)个有限结点组成一个具有层次关系的集合，当 n=0时称为空树，当 n>0时称为非空树。
对于非空树来说，它有且仅有一个称之为根的结点；除了根结点外的其余结点可分为 m(m>=0)多个互不相交的有限集T1，T2，…，Tm，其中每一个T集合本身又是一棵树，并且称为根结点的子树。

树的定义时递归的，它表明了树本身的固有特性，即一棵树由若干棵子树构成，可子树又由更小的子树构成。

树结构示意图如下（来自网络）：

树具有的特点：

• 1）树里面的元素称为结点（node）
• 2）没有父节点的结点称为根结点（root）
• 3）每一个非根结点有且只有一个父结点
• 4）除了根结点外，每个子结点可以分为多个不相交的子树。

2、树的基本概念

若一个结点有子树，那么该结点称为子树根的“双亲”，子树的根称为该结点的“孩子”。有相同双亲的结点互为“兄弟”。一个结点的所有子树上的任何结点都是该结点的后裔。从根结点到某个结点的路径上的所有结点都是该结点的祖先。

• 结点：树里面的一个独立单元（元素）。如上图中 A、B等。
• 父子关系：结点之间相连的边。
• 子树：当结点大于 1时，其余的结点分为的互不相交的集合称为子树
• 叶子结点：度为 0的结点称为叶子或终端结点。
• 非终端结点：度不为 0的结点称为非终端结点或分支结点。除根结点外,非终端结点也称为内部结点。
• 双亲和孩子：某结点的子结点称为该结点的孩子；该结点称为孩子的双亲。
• 兄弟：具有同一个双亲的孩子结点称为兄弟结点。
• 堂兄弟：双亲在同一层的结点互为堂兄弟。
• 子孙：以某结点的子树上任意一个结点都为该结点的子孙。
• 祖先：从根到该结点的双亲所经过的所有结点称为该结点的祖先。
• 森林：由 m（m>=0）棵互不相交的树的集合称为森林。对森林加上一个根，森林即成为树；删去根，树即成为森林。
• 有序树和无序树：如果树中节点的各子树看成从左至右是有次序的不能互换，则称该树为有序树，否则称为无序树。

还有几个很重要的概念：

• 结点的度：一个结点拥有子树的个数称为该拥有的度。如上图中：A有 4个度，D有 1个度。
• 树的度：树中最大的结点的度即为树的度。如上图中树的度为A节点的度为 4。
• 层次：从根结点开始定义，根结点为第一层，树中任一结点层次为其双亲层次加 1。
• 结点的高度：结点到叶子结点的最长路径
• 树的高度：根结点的高度
• 结点的深度：根结点到该结点的边个数
• 树的深度：树中节点的最大层次
• 结点的层数：结点的深度加 1。

二、二叉树

在树形结构中最重要的就是二叉树，很多经典的算法与数据结构其实都是通过二叉树发展而来。

1、二叉树的定义

二叉树是由 n(n>=0)个结点的有限集，当 n=0时称为空树，当 n>0时称为非空树。
对于非空树来说，它有且仅有一个称之为根的结点；除了根节点外的其余节点可分为两个互不相交的子集 T1和 T2，分别称为 T的左子树和右子树，且 T1和 T2本身也是二叉树。

二叉树与树的区别：

• 二叉树的每个节点至多只有两颗子树。
• 二叉树是有序树，有左右子树之分。

2、二叉树的性质

• 性质1：二叉树第i层上的结点数目最多为2i-1(i>=1)
• 性质2：深度为k的二叉树至多有(2^k)-1个结点（k>=1）
• 性质3：包含n个结点的二叉树的高度至少为(log2n)+1
• 性质4：在任意一棵二叉树中，若终端结点的个数为n0，度为2的结点数为n2，则n0=n2+1

性质4的证明：
证明：因为二叉树中所有结点的度数均不大于2，不妨设n0表示度为0的结点个数，n1表示度为1的结点个数，n2表示度为2的结点个数。三类结点加起来为总结点个数，于是便可得到：n=n0+n1+n2 (1)
由度之间的关系可得第二个等式：n=n00+n11+n2*2+1即n=n1+2n2+1 (2)
将（1）（2）组合在一起可得到n0=n2+1

3、二叉树的分类

二叉树有几个特殊的分类如下：

3.1 满二叉树

定义：高度为h，并且由2h-1个结点组成的二叉树，称为满二叉树。即：除叶子结点外，每个结点都有左右两个子结点。

3.2 完全二叉树

定义：一棵二叉树中，只有最下面两层结点的度可以小于2，并且最下层的叶结点集中在靠左的若干位置上，这样的二叉树称为完全二叉树。即：除最后一层外，其他的结点个数必须达到最大，并且最后一层结点都连续靠左排列。

特点：

• 叶子结点只能出现在最下层和次下层，且最下层的叶子结点集中在树的左部。
• 一棵满二叉树必定是一棵完全二叉树，而完全二叉树未必是满二叉树。

3.3 非完全二叉树

除了上面两种的二叉树，剩下的可以认为属于非完全二叉树。

4、二叉树的存储

1）基于数组存储：
利用数组下标。假设A为 i，则 B=2i, C=2i+1，依次类推，如果没有的结点，数组的位置需要保留。
如果针对非完全二叉树来使用数组来存储的话会浪费很多空间，那么就需要使用链表存储。
2）基于链表存储。
注意：数组的性能是高效的，并且不需要开额外的指针。所以如果是一课完全二叉树的话我们就可以用数组来实现。

三、二叉树的遍历

1、二叉树的遍历

1.1 先序遍历(PreOrder)

先（前）序遍历：访问根结点的操作发生在遍历其左右子树之前

具体操作：若二叉树非空，则依次执行如下操作：

• 1. 访问根结点；
• 2. 遍历左子树；
• 3. 遍历右子树。

1.2 中序遍历( InOrder)

中序遍历：访问根结点的操作发生在遍历其左右子树之中（间）。

具体操作： 若二叉树非空，则依次执行如下操作：

• 1. 遍历左子树；
• 2. 访问根结点；
• 3. 遍历右子树。

1.3 后序遍历(PostOrder)

后序遍历：访问根结点的操作发生在遍历其左右子树之后。

具体操作： 若二叉树非空，则依次执行如下操作：

• 1. 遍历左子树；
• 2. 遍历右子树；
• 3. 访问根结点。

1.4 层次遍历

层次遍历即为从上到下，从左到右依次访问二叉树的每个结点。

实现思路：用一个队列保存被访问的当前节点的左右孩子以实现层序遍历。

• 1）我们定义一个队列，先将根结点入队；
• 2）当前结点是队头结点，将其出队并访问；
• 3）若当前结点的左结点不为空将左结点入队；若当前结点的右结点不为空将其入队即可。

2、代码示例

1）基于链表存储二叉树

@Data
@AllArgsConstructor
@NoArgsConstructor
public class BinaryTree {

	// 结点元素
	private String data;
	private BinaryTree left;
	private BinaryTree right;

	/**
	 * 输出结点元素
	 * 
	 * @param node
	 */
	public void print(BinaryTree node) {
		System.out.print(node.getData());
	}

	/**
	 * 前序遍历: 根(输出) 左 右 <br/>
	 * 时间复杂度：O(2*n) => O(n);
	 * 
	 * @param root
	 */
	public void pre(BinaryTree root) {
		if (root == null) {// 空树
			return;
		}
		print(root);
		if (root.getLeft() != null) {
			pre(root.getLeft()); // 认为是子树,分解子问题
		}
		if (root.getRight() != null) {
			pre(root.getRight());
		}
	}

	/**
	 * 中序遍历：左 根(输出) 右
	 * 
	 * @param root
	 */
	public void in(BinaryTree root) {
		if (root == null) {// 空树
			return;
		}
		if (root.getLeft() != null) {
			in(root.getLeft()); 
		}
		print(root);
		if (root.getRight() != null) {
			in(root.getRight());
		}
	}

	/**
	 * 后序遍历：左 右 根(输出)
	 * 
	 * @param root
	 */
	public void post(BinaryTree root) {
		if (root == null) {// 空树
			return;
		}
		if (root.getLeft() != null) {
			post(root.getLeft()); 
		}
		if (root.getRight() != null) {
			post(root.getRight());
		}
		print(root);
	}

	/**
	 * 层次遍历
	 * 
	 * @param root
	 * @return
	 */
	public List<String> levelOrder(BinaryTree root) {
		List<String> levelList = new ArrayList<>();
		if (root == null) {// 空树
			return levelList;
		}

		// 定义一个队列
		Queue<BinaryTree> queue = new LinkedList<>();
		queue.offer(root);// offer方法表示添加元素到队尾
		while (!queue.isEmpty()) {
			BinaryTree temp = queue.poll();// poll方法删除队头元素
			levelList.add(temp.data);
			if (temp.left != null) {
				queue.offer(temp.left);
			}
			if (temp.right != null) {
				queue.offer(temp.right);
			}
		}
		return levelList;
	}

}

2）测试

    public static void main(String[] args) {
        // 插入数据小技巧，先插入叶子结点
        BinaryTree D = new BinaryTree("D", null, null);
        BinaryTree H = new BinaryTree("H", null, null);
        BinaryTree K = new BinaryTree("K", null, null);
        BinaryTree C = new BinaryTree("C", D, null);
        BinaryTree G = new BinaryTree("G", H, K);
        BinaryTree B = new BinaryTree("B", null, C);
        BinaryTree F = new BinaryTree("F", G, null);
        BinaryTree E = new BinaryTree("E", null, F);
        BinaryTree A = new BinaryTree("A", B, E);

        BinaryTree binaryTree = new BinaryTree();
        System.out.println("前序遍历：");
        binaryTree.pre(A);
        System.out.println();
        
        System.out.println("中序遍历：");
        binaryTree.in(A);
        System.out.println();
        
        System.out.println("后序遍历：");
        binaryTree.post(A);
        System.out.println();
        
        System.out.println("层次遍历：");
        List<String> levelOrderList = binaryTree.levelOrder(A);
        System.out.println(levelOrderList);
    }

– 求知若饥，虚心若愚。