二叉树的深度优先遍历和广度优先遍历

1. 分析

二叉树的深度优先遍历的非递归的通用做法是采用栈,广度优先遍历的非递归的通用做法是采用队列。

深度优先遍历:对每一个可能的分支路径深入到不能再深入为止,而且每个结点只能访问一次。要特别注意的是,二叉树的深度优先遍历比较特殊,可以细分为先序遍历、中序遍历、后序遍历。具体说明如下:

  • 先序遍历:对任一子树,先访问根,然后遍历其左子树,最后遍历其右子树。
  • 中序遍历:对任一子树,先遍历其左子树,然后访问根,最后遍历其右子树。
  • 后序遍历:对任一子树,先遍历其左子树,然后遍历其右子树,最后访问根。

广度优先遍历:又叫层次遍历,从上往下对每一层依次访问,在每一层中,从左往右(也可以从右往左)访问结点,访问完一层就进入下一层,直到没有结点可以访问为止。

2. 举例说明

对下图所示的二叉排序树进行遍历,要求使用先序遍历(递归、非递归)、中序遍历(递归、非递归)、后序遍历(递归、非递归)和广度优先遍历。

2.1 参考代码

package BinaryTreeTraverseTest;

import java.util.LinkedList;
import java.util.Queue;

/**
 * 二叉树的深度优先遍历和广度优先遍历
 * @author Fantasy
 * @version 1.0 2016/10/05 - 2016/10/07
 */
public class BinaryTreeTraverseTest {
    public static void main(String[] args) {
		
	BinarySortTree<Integer> tree = new BinarySortTree<Integer>();
        
        tree.insertNode(35);
        tree.insertNode(20);
        tree.insertNode(15);
        tree.insertNode(16);
        tree.insertNode(29);
        tree.insertNode(28);
        tree.insertNode(30);
        tree.insertNode(40);
        tree.insertNode(50);
       	tree.insertNode(45);
       	tree.insertNode(55);
        
       	System.out.print("先序遍历(递归):");
       	tree.preOrderTraverse(tree.getRoot());
       	System.out.println();
       	System.out.print("中序遍历(递归):");
       	tree.inOrderTraverse(tree.getRoot());
      	System.out.println();
       	System.out.print("后序遍历(递归):");
       	tree.postOrderTraverse(tree.getRoot());
       	System.out.println();
        
       	System.out.print("先序遍历(非递归):");
       	tree.preOrderTraverseNoRecursion(tree.getRoot());
       	System.out.println();
       	System.out.print("中序遍历(非递归):");
       	tree.inOrderTraverseNoRecursion(tree.getRoot());
       	System.out.println();
       	System.out.print("后序遍历(非递归):");
       	tree.postOrderTraverseNoRecursion(tree.getRoot());
       	System.out.println();
        
       	System.out.print("广度优先遍历:");
       	tree.breadthFirstTraverse(tree.getRoot());
    }
}

/**
 * 结点
 */
class Node<E extends Comparable<E>> {
	
    E value;
    Node<E> left;
    Node<E> right;
    
    Node(E value) {
        this.value = value;
        left = null;
        right = null;
    }
    
}

/**
 * 使用一个先序序列构建一棵二叉排序树(又称二叉查找树)
 */
class BinarySortTree<E extends Comparable<E>> {
	
    private Node<E> root;
    
    BinarySortTree() {
        root = null;
    }
    
    public void insertNode(E value) {	
        if (root == null) {
            root = new Node<E>(value);
            return;
        }    
        Node<E> currentNode = root;
        while (true) {
            if (value.compareTo(currentNode.value) > 0) {
            	if (currentNode.right == null) {
                    currentNode.right = new Node<E>(value);
                    break;
                }
                currentNode = currentNode.right;
            } else {
                if (currentNode.left == null) {
                    currentNode.left = new Node<E>(value);
                    break;
                }
                currentNode = currentNode.left;
            }
        }
    }
    
    public Node<E> getRoot(){
        return root;
    }

    /**
     * 先序遍历二叉树(递归)
     * @param node
     */
    public void preOrderTraverse(Node<E> node) {
    	System.out.print(node.value + " ");
    	if (node.left != null)
    		preOrderTraverse(node.left);
    	if (node.right != null)
    		preOrderTraverse(node.right);
    }
    
    /**
     * 中序遍历二叉树(递归)
     * @param node
     */
    public void inOrderTraverse(Node<E> node) {
    	if (node.left != null)
    		inOrderTraverse(node.left);
    	System.out.print(node.value + " ");
    	if (node.right != null)
    		inOrderTraverse(node.right);
    }
    
    /**
     * 后序遍历二叉树(递归)
     * @param node
     */
    public void postOrderTraverse(Node<E> node) {
    	if (node.left != null)
    		postOrderTraverse(node.left);
    	if (node.right != null)
    		postOrderTraverse(node.right);
    	System.out.print(node.value + " ");
    }
    
    /**
     * 先序遍历二叉树(非递归)
     * @param root
     */
    public void preOrderTraverseNoRecursion(Node<E> root) {
    	LinkedList<Node<E>> stack = new LinkedList<Node<E>>();
    	Node<E> currentNode = null;
    	stack.push(root);
    	while (!stack.isEmpty()) {
    		currentNode = stack.pop();
    		System.out.print(currentNode.value + " ");
    		if (currentNode.right != null)
    			stack.push(currentNode.right);
    		if (currentNode.left != null)
    			stack.push(currentNode.left);
    	}
    }
    
    /**
     * 中序遍历二叉树(非递归)
     * @param root
     */
    public void inOrderTraverseNoRecursion(Node<E> root) {
    	LinkedList<Node<E>> stack = new LinkedList<Node<E>>();
    	Node<E> currentNode = root;
    	while (currentNode != null || !stack.isEmpty()) {
    		// 一直循环到二叉排序树最左端的叶子结点(currentNode是null)
    		while (currentNode != null) {
    			stack.push(currentNode);
    			currentNode = currentNode.left;
    		}
			currentNode = stack.pop();
			System.out.print(currentNode.value + " ");
			currentNode = currentNode.right;
    	}	
    }
    
    /**
     * 后序遍历二叉树(非递归)
     * @param root
     */
    public void postOrderTraverseNoRecursion(Node<E> root) {
    	LinkedList<Node<E>> stack = new LinkedList<Node<E>>();
    	Node<E> currentNode = root;
    	Node<E> rightNode = null;
    	while (currentNode != null || !stack.isEmpty()) {
    		// 一直循环到二叉排序树最左端的叶子结点(currentNode是null)
    		while (currentNode != null) {
    			stack.push(currentNode);
    			currentNode = currentNode.left;
    		}
    		currentNode = stack.pop();
    		// 当前结点没有右结点或上一个结点(已经输出的结点)是当前结点的右结点,则输出当前结点
    		while (currentNode.right == null || currentNode.right == rightNode) {
    			System.out.print(currentNode.value + " ");
    			rightNode = currentNode;
    			if (stack.isEmpty()) {
    				return; //root以输出,则遍历结束
    			}
    			currentNode = stack.pop();
    		}
    		stack.push(currentNode); //还有右结点没有遍历
    		currentNode = currentNode.right;
    	}
    }
    
    /**
     * 广度优先遍历二叉树,又称层次遍历二叉树
     * @param node
     */
    public void breadthFirstTraverse(Node<E> root) {
    	Queue<Node<E>> queue = new LinkedList<Node<E>>();
    	Node<E> currentNode = null;
    	queue.offer(root);
    	while (!queue.isEmpty()) {
    		currentNode = queue.poll();
    		System.out.print(currentNode.value + " ");
    		if (currentNode.left != null)
    			queue.offer(currentNode.left);
    		if (currentNode.right != null)
    			queue.offer(currentNode.right);
    	}
    }
    
}

2.2 输出结果

先序遍历(递归):35 20 15 16 29 28 30 40 50 45 55 
中序遍历(递归):15 16 20 28 29 30 35 40 45 50 55 
后序遍历(递归):16 15 28 30 29 20 45 55 50 40 35 
先序遍历(非递归):35 20 15 16 29 28 30 40 50 45 55 
中序遍历(非递归):15 16 20 28 29 30 35 40 45 50 55 
后序遍历(非递归):16 15 28 30 29 20 45 55 50 40 35 
广度优先遍历:35 20 40 15 29 50 16 28 30 45 55 

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值