二叉树的深搜和广搜

二叉树是计算机中一个重要的数据结构，在这里主要谈一下二叉树的深度优先搜索(DFS)和广度优先搜索(BFS)。

所谓DFS，就是沿着树的深度一直往下，一直到达一个叶子节点，然后再返回遍历剩余的节点。根据树的性质，树结构不存在环，因此遍历的时候不需要标记。如果在遍历一个图的时候，因为图中有环的存在，因此需要标记访问过的节点，以防止程序进入死循环。言归正传，树的DFS有三种方式，分别为：前序遍历，中序遍历，和后序遍历。根据这个性质，我们很容易想到用堆栈完成DFS。遍历的时候我们将元素压栈，利用堆栈后进先出的性质来实现不同的遍历。
 

所谓前序遍历，就是每次都先访问根节点，然后依次为左子树，和右子树（根->左->右）。根据前序遍历的规定，左子树先于右子树，依次压栈的时候从右子树开始。代码如下：

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
 }

public class Solution {
    public List preorderTraversal(TreeNode root) {
        List list = new ArrayList();
        Stack stack = new Stack();
        if(root == null) return list;
        stack.push(root);

        while(!stack.empty()) {
            TreeNode node = stack.pop();
            list.add(node.val);
            if(node.right != null) 
                stack.push(node.right);
            if(node.left != null)
                stack.push(node.left);
        }
        return list;
    }
}

中序遍历是从左子树开始，然后依次为根节点，右子树（左->根->右），注意这里的根节点是指的每个子树的根结点。代码如下：

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
 }

public List inorderTraversal(TreeNode root) {
        List list = new ArrayList();
        Stack stack = new Stack();
        if (root == null) return list;
        while(!stack.empty() || root != null) {
            if(root != null){
                stack.push(root);
                root = root.left;
            } else {
                root = stack.pop();
                list.add(root.val);
                root = root.right;
            }
        }
        return list;
 }

后序遍历是先遍历左子树，然后依次为右子树，根节点。因为根节点在最后遍历，所以在程序完成时如果按照左右根的方式会比较繁琐。我们不妨换一下思路，在完成前序遍历后，我们发现前序遍历是根->左->右，后序遍历时左->右->根，如果我们按照根->右->左的方式进行遍历，然后把结果倒转，就是左->右->根了。代码如下：

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
 }

  public List postorderTraversal(TreeNode root) {
        LinkedList list = new LinkedList();
        Stack stack = new Stack();
        if(root == null)
            return list;
        stack.push(root);
        while(!stack.empty()) {
            TreeNode node = stack.pop();
            list.addFirst(node.val);
            if(node.left != null)
                stack.push(node.left);
            if(node.right != null)
                stack.push(node.right);
        }
        return list;
 }

以上我们介绍了二叉树的三种遍历方式，它们都属于深度优先遍历，对于深度优先遍历，我们都用堆栈实现。接下来我们介绍一下二叉树的广度优先遍历。

BFS，即广度优先遍历，它时沿着树的宽度进行遍历，从第一层直到最后一层，一直到遍历完树中所有的节点。对于BFS，我们通常用队列来实现，队列先进先出的性质正好满足BFS的要求。
我们先从根节点开始，然后加入到队列中，依次为左子树，右子树，然后每次从队列中取出一个节点，都一次访问它的左孩子和右孩子，直到遍历完所有的节点。代码如下：

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
 }

public void BFS(TreeNode root) {
	List list = new ArrayList();
        Queue queue = new LinkedList();
        if(root == null) return list;
        queue.offer(root);

        while(!queue.isEmpty()) {
            TreeNode node = queue.poll();
            list.add(node.val);
            if(node.left != null)
                queue.offer(node.left);
            if(node.right != null)
                queue.offer(node.right);
        }
        return list;
}

 

遍历分为：
1.深度（Depth）优先搜索DFS：一个递归过程，有回退过程。尽可能“深”地搜索图。在深度优先搜索中，对于最新发现的顶点，如果它还有以此为起点而未探测到的边，就沿此边继续搜索下去。当结点V的所有边都已被探寻过，搜索将回溯到发现结点V有那条边的始结点，则选择其中一个作为源结点并重复以上过程，整个进程反复进行直到所有结点都被发现为止。
2.广度（Breath）优先搜索BFS：一个分层的搜索过程，没有回退过程，是非递归的。只是每次都尽可能地扩展当前节点的邻居节点，之后再向其子结点进行扩展。

应用上的区别：
BFS 常用于找单一的最短路线，它的特点是 “搜到就是最优解”，而 DFS 用于找所有解的问题，它的空间效率高，而且找到的不一定是最优解，必须记录并完成整个搜索，故一般情况下，深搜需要非常高效的剪枝
BFS:对于解决最短或最少问题特别有效，而且寻找深度小，但缺点是内存耗费量大（需要开大量的数组单元用来存储状态）。
DFS：对于解决遍历和求所有问题有效，对于问题搜索深度小的时候处理速度迅速，然而在深度很大的情况下效率不高。

实现时用到的数据结构：
深度优先搜索用栈（stack）来实现，整个过程可以想象成一个倒立的树形：
1、把根节点压入栈中。
2、每次从栈中弹出一个元素，搜索所有在它下一级的元素，把这些元素压入栈中。并把这个元素记为它下一级元素的前驱。
3、找到所要找的元素时结束程序。
4、如果遍历整个树还没有找到，结束程序。
当然DFS也可以直接利用函数进行递归。
广度优先搜索使用队列（queue）来实现，整个过程也可以看做一个倒立的树形：
1、把根节点放到队列的末尾。
2、每次从队列的头部取出一个元素，查看这个元素所有的下一级元素，把它们放到队列的末尾。并把这个元素记为它下一级元素的前驱。
3、找到所要找的元素时结束程序。
4、如果遍历整个树还没有找到，结束程序。
BFS根据实际情况可能要用到优先队列。

 

// 递归中序遍历
public void inOrder(BinaryTreeNode current) {
	if (current != null) {
		inOrder(current.llink);
		System.out.print(current.info);
		inOrder(current.rlink);
	}
}

// 非递归中序遍历
public void nonRecursiveInOrder() {
	Stack stack = new Stack();
	BinaryTreeNode current;
	current = root;
	while ((current != null) || (!stack.empty())) {
		if (current != null) {
			stack.push(current);
			current = current.llink;
		} else {
			current = (BinaryTreeNode) stack.peek();
			stack.pop();
			System.out.print(current.info);
			current = current.rlink;
		}
	}
}

// 递归前序遍历
public void preOrder(BinaryTreeNode current) {
	if (current != null) {
		System.out.print(current.info);
		preOrder(current.llink);
		preOrder(current.rlink);
	}
}

// 非递归前序遍历
public void nonRecursivePreOrder() {
	Stack stack = new Stack();
	BinaryTreeNode current;
	current = root;
	while ((current != null) || (!stack.isEmpty())) {
		if (current != null) {
			System.out.print(current.info);
			stack.push(current);
			current = current.llink;
		} else {
			current = (BinaryTreeNode) stack.peek();
			stack.pop();
			current = current.rlink;
		}
	}
}

// 递归后序遍历
public void postOrder(BinaryTreeNode current) {
	if (current != null) {
		postOrder(current.llink);
		postOrder(current.rlink);
		System.out.print(current.info);
	}
}

// 非递归后序遍历
public void notRecursivePostOrder() {
	Stack stack = new Stack();
	BinaryTreeNode current;
	current = root;
	while ((current != null) || (!stack.isEmpty())) {
		if (current != null) {
			current.isFirst = true;
			stack.push(current);
			current = current.llink;
		} else {
			current = stack.peek();
			stack.pop();
			if (current.isFirst) {
				current.isFirst = false;
				stack.push(current);
				current = current.rlink;
			} else {
				System.out.print(current.info);
				current = null;
			}
		}
	}
}

// 树的层次遍历
public void bfs() {
	Queue queue = new LinkedList();
	BinaryTreeNode current;
	current = root;
	while ((current != null) || (!queue.isEmpty())) {
		if (current != null) {
			System.out.print(current.info);
			queue.add(current.llink);
			queue.add(current.rlink);
			current = queue.poll();
		} else {
			current = queue.poll();
		}
	}
}

public class BinaryTreeNode {
	private BinaryTreeNode llink = null;
	private BinaryTreeNode rlink = null;
	private int info;
	private boolean isFirst;

	public BinaryTreeNode(int info) {
		this.info = info;
	}
}

public void initTree() {
	root = new BinaryTreeNode(1);
	root.llink = new BinaryTreeNode(2);
	root.rlink = new BinaryTreeNode(3);
	root.llink.llink = null;
	root.llink.rlink = new BinaryTreeNode(4);
}

public BinaryTreeNode getRoot() {
	return root;
}

public void setRoot(BinaryTreeNode root) {
	this.root = root;
}

public static void main(String[] args) {
	Tree tree = new Tree();
	tree.initTree();
	// tree.preOrder(tree.getRoot());
	// tree.nonRecursivePreOrder();
	// tree.inOrder(tree.getRoot());
	// tree.nonRecursiveInOrder();
	// tree.postOrder(tree.getRoot());
	// tree.notRecursivePostOrder();
	tree.bfs();
}