【二叉树】二叉树的三种基本遍历方式以及递归序

二叉树的三种基本遍历方式

二叉树在数据结构中非常重要，它的基本构成就是一个节点有自己的数据，同时还有两个指向另外节点的地址，这样的节点构成的树状结构

这里是我画的原图链接

先序

每一颗树打印都是先头再左再右

先序：每一颗树打印都是先头再左再右  
示例：1，2，4，5，3，6，7  
解释：
	1这棵树，先打印自己1，再打印左2，再打印右3；1，2，3            
	2这棵树，先打印自己2，再打印左4，再打印右5；2，4，5            
	3这颗树，先打印自己3，再打印左6，再打印右7；3，6，7            
	4、5、6、7这些树，下面都是null，只打印自己；            
所以，打印整棵树就是，把2打印出来的放在1这棵树的打印2的位置：1，2，4，5，3            
然后，再把3打印出来的放在1这棵树的打印3的位置：1，2，4，5，3，6，7            
得到最终结果

中序

每一棵树打印都是先左再头再右

中序：每一颗树打印都是先左再头再右  
示例：4，2，5，1，6，3，7  
解释：
	1这棵树，先打印左2，再打印自己1，再打印右3；2，1，3            
	2这棵树，先打印左4，再打印自己2，再打印右5；4，2，5            
	3这颗树，先打印左6，再打印自己3，再打印右7；6，3，7            
	4、5、6、7这些树，下面都是null，只打印自己；            
所以，打印整棵树就是，把2打印出来的放在1这棵树的打印2的位置：4，2，5，1，3            
然后，再把3打印出来的放在1这棵树的打印3的位置：4，2，5，1，6，3，7            
得到最终结果

后序

每一棵树都是先左再右再头

后序：每一颗树打印都是先左再右再头  
示例：4，5，2，6，7，3，1  
解释：
	1这棵树，先打印左2，再打印右3，再打印自己1；2，3，1            
	2这棵树，先打印左4，再打印右5，再打印自己2；4，5，2            
	3这颗树，先打印左6，再打印右7，再打印自己3；6，7，3            
	4、5、6、7这些树，下面都是null，只打印自己；            
所以，打印整棵树就是，把2打印出来的放在1这棵树的打印2的位置：4，5，2，3，1            
然后，再把3打印出来的放在1这棵树的打印3的位置：4，5，2，6，7，3，1            
得到最终结果

这是我画的原图链接

实现

1. 先实现每一个节点的先序、中序、后序。
2. 递归每个节点。

	/**
	 * 先序
	 * @param head
	 */
	public static void preorder(Node head) {
		if (head == null) {
			return;
		}
		System.out.print(head.value+" ");//先头
		preorder(head.left);//再左
		preorder(head.right);//再右
	}

	/**
	 * 中序
	 * @param head
	 */
	public static void ims(Node head) {
		if (head == null) {
			return;
		}
		ims(head.left);//先左
		System.out.print(head.value+" ");//再头
		ims(head.right);//再右
	}

	/**
	 * 后序
	 * @param head
	 */
	public static void posorder(Node head) {
		if (head == null) {
			return;
		}
		posorder(head.left);//先左
		posorder(head.right);//再右
		System.out.print(head.value+" ");//再自己
	}

测试代码：

	public static void main(String[] args) {
		Node head = new Node(1);
		head.left = new Node(2);
		head.right = new Node(3);
		head.left.left = new Node(4);
		head.left.right = new Node(5);
		head.right.left = new Node(6);
		head.right.right = new Node(7);
		preorder(head);
		System.out.println();
		System.out.println("========");
		ims(head);
		System.out.println();
		System.out.println("========");
		posorder(head);
		System.out.println();
		System.out.println("========");
	}

测试结果：

1 2 4 5 3 6 7 
========
4 2 5 1 6 3 7 
========
4 5 2 6 7 3 1 
========

进阶

通过上面的代码，我们可以找到规律，就有了递归序。

递归序

每一个节点都进入了3次，
在第一次来到节点打印，就实现了先序
在第二次来到节点打印，就实现了中序
在第三次来到节点打印，就实现了后序

这里是我画的原图链接

   public static void recursiveOrder(Node head) {
		if (head == null) {
			return;
		}
		// 第一次来到本节点
		recursiveOrder(head.left);
		// 第二次来到本节点
		recursiveOrder(head.right);
		// 第三次来到本节点
	}