Java实现二叉树前序遍历（递归+非递归）

一、二叉树的定义

二叉排序树的结构就是一个父节点挂一个或者两个子节点，二叉树有如下特点：

• 节点的左子树小于节点本身
• 节点的右子树大于节点本身
• 左右子树同样为二叉搜索树

下面是一个二叉排序树的图：

二、二叉排序树查找

二叉搜索树是均衡二叉树的基础，比如我们要查找50这个节点，那么它是怎么搜索的呢？
第一步：首先查找到根节点，值为 60 的节点。

第二步：比较我们要找的值 50 与该节点的大小，发现50比根节点60要小，所以又找根节点的做节点20

第三步：比较我们要找的值 50 与该节点的大小，发现50比该节点20要大，所以又找该节点20的右节点50

第四步：比较我们要找的值 50 与该节点50的大小，发现该节点等于我们要找的节点，恭喜找到了我们要找的节点，所以将该节点返回

我们经过四步就找到了我们要找的节点，这就是我们所说的二分查找算法，但是还是有缺陷的，例如下面的图：

这就是典型的大长腿瘸子，这种算法和单链表的查询性能一样，这个就使查询的性能大打折扣了，于是就出现了平衡二叉树，将上面的图自动转化为，下图：

这样算法有自动的维护在二分查找算法，这样性能就大大提高了，不会出现典型的大长腿瘸子的情况了。

三、二叉排序树的遍历

1.前序遍历（递归=），结构图如下

前序遍历（递归），前序遍历访问节点的顺序是：根节点-左儿子-右儿子，代码如下

public void preOrderRecur(Node root) {
		if (root == null) {
			return;
		}
		System.out.print(root.data + " -> ");
		preOrderRecur(root.left);
		preOrderRecur(root.right);
	}

执行过程图解
（1）执行preOrderRecur（Node root）方法，访问节点60，打印“60”。

第二步：
（1）执行preOrderRecur（root.left）方法，访问节点20，不为空，打印“20”。

第三步：
（1）递归调用preOrderRecur（20.left）方法，访问节点10，不为空，打印“10”。

第四步：
（1）递归调用preOrderRecur（10.left）方法，节点为空，返回。
（2）递归调用preOrderRecur（10.right）方法，节点为空，返回。
（3）返回上一层20节点处，调用preOrderRecur（20.right）方法，访问到50节点，打印50。

第五步：
（1）递归调用preOrderRecur（50.left）方法，访问倒40，打印“40”。

第六步：
（1）递归调用preOrderRecur（40.left）方法，为空，直接返回。
（2）递归调用preOrderRecur（40.right）方法，为空，直接返回。
（3）返回上一层，递归调用preOrderRecur（50.right）方法，访问到55，打印“55”。

第七步：
（1）递归调用preOrderRecur（55.left）方法，为空，直接返回。
（2）递归调用preOrderRecur（55.right）方法，为空，直接返回。
（3）返回上一层50，执行时完毕，再返回上一层20，也执行完毕，再返回上一层60，递归调用preOrderRecur（60.right），访问到75，打印“75”。

第八步：
（1）递归调用preOrderRecur（75.left）方法，访问到62，打印“62”。

第九步：
（1）递归调用preOrderRecur（62.left）方法，访问到61，打印“61”。

第九步：
（1）递归调用preOrderRecur（61.left）方法，为空，直接返回。
（2）递归调用preOrderRecur（61.right）方法，为空，直接返回。
（3）返回上一层62，递归调用preOrderRecur（61.right），访问到69，打印“69”。

第10步：
（1）递归调用preOrderRecur（69.left）方法，为空，直接返回。
（2）递归调用preOrderRecur（69.right）方法，为空，直接返回。
（3）返回上一层62，执行完毕，再返回上一层75，递归调用preOrderRecur（75.right），访问到80，打印“80”。
（4）递归调用preOrderRecur（80.left）方法，为空，直接返回。
（5）递归调用preOrderRecur（80.right）方法，为空，直接返回。
（6）返回上一层75，执行完毕，再返回上一层60，最后跳出方法。

第10步：
（1）最后的输出结果60、20、10、50、40、55、75、62、61、69、80
2.前序遍历（非递归）
代码：

public void preOrder() {
		if (root == null)
			return;
		Node current;
		//把LinkedList当栈使用
		LinkedList<Node> s = new LinkedList<Node>();
		s.addFirst(root);
		while (!s.isEmpty()) {
			current = s.removeFirst();
			System.out.print(current.data + " -> ");
			if (current.right != null)
				s.addFirst(current.right);
			if (current.left != null)
				s.addFirst(current.left);
		}

	}

执行过程图截如下

第一步：
（1）s.addFirst(root);

第二步：
（1）取出60，打印“60”；
（2）60的左右孩子都不为空，先放入右孩子75，在放入左孩子20。

第三步：
（1）取出20，打印“20”；
（2）20的左右孩子都不为空，先放入右孩子50，在放入左孩子10。

第四步：
（1）取出10，打印“10”；
（2）10的左右孩子都为空，都不放入。

第五步：
（1）取出50，打印“50”；
（2）10的左右孩子都为空，都不放入。

第六步：
（1）取出75，打印“75”；
（2）75的左右孩子都不为空，先放入右孩子80，再放入左孩子62。

第七步：
（1）取出62，打印“62”；
（2）62的左右孩子都为空，都不放入。

第八步：
（1）取出80，打印“80”；
（2）80的左右孩子都为空，都不放入。
（3）最后s栈结构内容为空，跳出循环。

到此为止二叉树的前序遍历已经写完了，感觉整个人都不行了，想吐了，后面还会更新以下内容:

1. 中序遍历（递归+非递归）
2. 后序遍历（递归+非递归）
3. 层次遍历

更多的教程请关注：非科班的科班，今日的学习视频资源分享使shiro权限管理框架的全套学习视频，在后台回复：shiro，就可以获得学习视频