二叉树的遍历

深度优先搜索(DFS)后序遍历，前序遍历，中序遍历

广度优先搜索(BFS)层次遍历：

几种遍历方式

0.二叉树的构建

将0-9十个数按照层次遍历的顺序构建一个二叉树。

原理：用数组保存十个数字，给定节点index，其父节点的索引为\((index-1)/2\)，其左子树的索引为\(2*index+1\)，右子树的索引为\(2*index+2\)。

public class Test 
{
	public static void main(String[] args) {
		TreeNode[] node = new TreeNode[10];
		for (int i = 0; i < 10; i++) {
			node[i] = new TreeNode(i);
		}

		for (int i = 0; i < 10; i++) {
			if (2 * i + 1 < 10) {
				node[i].left = node[i * 2 + 1];
			}
			if (2 * i + 2 < 10) {
				node[i].right = node[i * 2 + 2];
			}
		}
		preOrder(node[0]);
	}
}

1.前序遍历

前序遍历（DLR，lchild,data,rchild），是二叉树遍历的一种，也叫做先根遍历、先序遍历、前序周游，可记做根左右。前序遍历首先访问根结点然后遍历左子树，最后遍历右子树。

前序遍历首先访问根结点然后遍历左子树，最后遍历右子树。在遍历左、右子树时，仍然先访问根结点，然后遍历左子树，最后遍历右子树。

若二叉树为空则结束返回，否则：

访问根结点。

前序遍历左子树。

前序遍历右子树。

前序遍历结果：ABDECF

需要注意的是：遍历左右子树时仍然采用前序遍历方法。

已知后序遍历和中序遍历，就能确定前序遍历。

其实在遍历二叉树的时候有三次遍历，比如前序遍历：A->B->D->D(D左子节点并返回到D)->D(D右子节点并返回到D)->B->E->E(左)->E(右)->->B->A->C->F->F(左)->F(右)->C->C(右)，所以可以用栈结构，把遍历到的节点压进栈，没子节点时再出栈。也可以用递归的方式，递归的输出当前节点，然后递归的输出左子节点，最后递归的输出右子节点。直接看代码更能理解：

前序遍历结果：0137849256

import java.util.Stack;

public class Test 
{
	public static void main(String[] args) {
		TreeNode[] node = new TreeNode[10];
		for (int i = 0; i < 10; i++) {
			node[i] = new TreeNode(i);
		}

		for (int i = 0; i < 10; i++) {
			if (2 * i + 1 < 10) {
				node[i].left = node[i * 2 + 1];
			}
			if (2 * i + 2 < 10) {
				node[i].right = node[i * 2 + 2];
			}
		}
		preOrder(node[0]);
	}

	/**
	 * 递归实现
	 * @param biTree
	 */
	public static void preOrderRe(TreeNode biTree)
	{
		System.out.println(biTree.value);
		TreeNode leftTree = biTree.left;
		if(leftTree != null)
		{
			preOrderRe(leftTree);
		}
		TreeNode rightTree = biTree.right;
		if(rightTree != null)
		{
			preOrderRe(rightTree);
		}
	}

	/**
	 * 迭代实现
	 * @param biTree
	 */
	public static void preOrder(TreeNode biTree)
	{
		// push(E e) 栈顶添加一个元素
		// pop(E e) 移除栈顶元素,如果栈顶没有元素将抛出异常
		Stack<TreeNode> stack = new Stack<TreeNode>();
		while(biTree != null || !stack.isEmpty())
		{
			while(biTree != null)
			{
				System.out.println(biTree.value);
				stack.push(biTree);
				biTree = biTree.left;
			}
			if(!stack.isEmpty())
			{
				biTree = stack.pop();
				biTree = biTree.right;
			}
		}
	}
}

// 树的结构
class TreeNode
{
	int value;
	TreeNode left;
	TreeNode right;

	TreeNode(int value)
	{
		this.value = value;
	}
}

2.中序遍历

中序遍历（LDR）是二叉树遍历的一种，也叫做中根遍历、中序周游。在二叉树中，先左后根再右。巧记：左根右。

中序遍历首先遍历左子树，然后访问根结点，最后遍历右子树

若二叉树为空则结束返回，

否则：

中序遍历结果：DBEAFC

（1）中序遍历左子树

（2）访问根结点

（3）中序遍历右子树

中序遍历结果：7381940526

import java.util.Stack;
public class Test 
{
	public static void main(String[] args)
	{
		//以数组形式生成一棵完全二叉树
		TreeNode[] node = new TreeNode[10];
		for(int i = 0; i < 10; i++)
		{
			node[i] = new TreeNode(i);
		}
		for(int i = 0; i < 10; i++)
		{
			if(i*2+1 < 10) {
				node[i].left = node[i*2+1];
			}
			if(i*2+2 < 10) {
				node[i].right = node[i*2+2];
			}
		}
		
		midOrderRecursive(node[0]);
		System.out.println();
		midOrder(node[0]);
	}
	

	/**
	 * 中序遍历递归实现
	 * @param tree
	 */
	public static void midOrderRecursive(TreeNode tree) {
		if (tree == null) {
			return ;
		} else {
			midOrderRecursive(tree.left);
			System.out.println(tree.value);
			midOrderRecursive(tree.right);
		}
	}

	/**
	 * 中序遍历迭代实现
	 * @param biTree
	 */
	public static void midOrder(TreeNode biTree)
	{
		Stack<TreeNode> stack = new Stack<TreeNode>();
		while(biTree != null || !stack.isEmpty())
		{
			while(biTree != null)
			{
				stack.push(biTree);
				biTree = biTree.left;
			}
			if(!stack.isEmpty())
			{
				biTree = stack.pop();
				System.out.println(biTree.value);
				biTree = biTree.right;
			}
		}
	}

}

/**
 * 节点结构
 */
class TreeNode
{
	int value;
	TreeNode left;
	TreeNode right;
	
	TreeNode(int value)
	{
		this.value = value;
	}
}

3.后序遍历（难点）

后序遍历（LRD）是二叉树遍历的一种，也叫做后根遍历、后序周游，可记做左右根。后序遍历有递归算法和非递归算法两种。在二叉树中，先左后右再根。巧记：左右根。

后序遍历首先遍历左子树，然后遍历右子树，最后访问根结点，在遍历左、右子树时，仍然先遍历左子树，然后遍历右子树，最后遍历根结点。即：

若二叉树为空则结束返回，

否则：

后序遍历结果：DEBFCA

后序遍历左子树
后序遍历右子树
访问根结点

已知前序遍历和中序遍历，（就可以构建出二叉树）就能确定后序遍历。

算法核心思想：
首先要搞清楚先序、中序、后序的非递归算法共同之处：用栈来保存先前走过的路径，以便可以在访问完子树后,可以利用栈中的信息,回退到当前节点的双亲节点,进行下一步操作。
后序遍历的非递归算法是三种顺序中最复杂的，原因在于，后序遍历是先访问左、右子树,再访问根节点，而在非递归算法中，利用栈回退到时，并不知道是从左子树回退到根节点，还是从右子树回退到根节点，如果从左子树回退到根节点，此时就应该去访问右子树，而如果从右子树回退到根节点，此时就应该访问根节点。所以相比前序和后序，必须得在压栈时添加信息，以便在退栈时可以知道是从左子树返回，还是从右子树返回进而决定下一步的操作。

后序遍历结果： 7839415620

import java.util.Stack;
public class Test 
{
	public static void main(String[] args)
	{
		//以数组形式生成一棵完全二叉树
		TreeNode[] node = new TreeNode[10];
		for(int i = 0; i < 10; i++)
		{
			node[i] = new TreeNode(i);
		}
		for(int i = 0; i < 10; i++)
		{
			if(i*2+1 < 10) {
				node[i].left = node[i*2+1];
			}
			if(i*2+2 < 10) {
				node[i].right = node[i*2+2];
			}
		}
		
		postOrderRe(node[0]);
		System.out.println();
		postOrder(node[0]);
		// 7839415620
	}

	//后序遍历递归实现
	public static void postOrderRe(TreeNode biTree)
	{
		if(biTree == null) {
			return;
		} else
		{
			postOrderRe(biTree.left);
			postOrderRe(biTree.right);
			System.out.print(biTree.value);
		}
	}


	/**
	 * 后序遍历迭代实现
	 * @param treeNode
	 */
	public static void postOrder(TreeNode treeNode) {
		//在辅助栈里表示左节点和右节点
		int left = 1, right = 2;
		Stack<TreeNode> stack = new Stack<>();
		//辅助栈，用来判断子节点返回父节点时处于左节点还是右节点。
		Stack<Integer> stack1 = new Stack<>();

		while (treeNode != null || !stack.isEmpty()) {
			//将节点压入栈1，并在栈2将节点标记为左节点
			while (treeNode != null) {
				stack1.push(left);
				stack.push(treeNode);
				treeNode = treeNode.left;
			}
			//如果是从右子节点返回父节点，则任务完成，将两个栈的栈顶弹出
			if (!stack.isEmpty() && stack1.peek() == right) {
				stack1.pop();
				System.out.print(stack.pop().value);
			}
			//如果是从左子节点返回父节点，则将标记改为右子节点
			if (!stack.isEmpty() && stack1.peek() == left) {
				stack1.pop();
				stack1.push(right);
				treeNode = stack.peek().right;
			}
		}
	}
}

//节点结构
class TreeNode
{
	int value;
	TreeNode left;
	TreeNode right;
	
	TreeNode(int value)
	{
		this.value = value;
	}
}

4.层次遍历

与树的前中后序遍历的DFS思想不同，层次遍历用到的是BFS思想。一般DFS用递归去实现（也可以用栈实现），BFS需要用队列去实现。
层次遍历的步骤是：

对于不为空的结点，先把该结点加入到队列中
从队中拿出结点，如果该结点的左右结点不为空，就分别把左右结点加入到队列中
重复以上操作直到队列为空

import java.util.LinkedList;
public class Test
{
	public static void main(String[] args)
	{
		//以数组形式生成一棵完全二叉树
		TreeNode[] node = new TreeNode[10];
		for(int i = 0; i < 10; i++)
		{
			node[i] = new TreeNode(i);
		}
		for(int i = 0; i < 10; i++)
		{
			if(i*2+1 < 10) {
				node[i].left = node[i*2+1];
			}
			if(i*2+2 < 10) {
				node[i].right = node[i*2+2];
			}
		}
		levelOrder(node[0]);
	}

	/**
	 * 层次遍历
	 * @param treeNode
	 */
	public static void levelOrder(TreeNode treeNode) {
		if(treeNode == null) {
			return;
		}
		LinkedList<TreeNode> list = new LinkedList<TreeNode>();
		list.add(treeNode);
		TreeNode currentNode;
		while(!list.isEmpty())
		{
			currentNode = list.poll();
			System.out.println(currentNode.value);
			if(currentNode.left != null) {
				list.add(currentNode.left);
			}
			if(currentNode.right != null) {
				list.add(currentNode.right);
			}
		}
	}
}

//节点结构
class TreeNode
{
	int value;
	TreeNode left;
	TreeNode right;
	TreeNode(int value)
	{
		this.value = value;
	}
}

先序遍历特点：第一个值是根节点
中序遍历特点：根节点左边都是左子树，右边都是右子树

参考二叉树的前序遍历，中序遍历，后序遍历（Java实现）

posted @ 2020-06-04 14:49 g_curry 阅读(184) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

g_curry