zoukankan      html  css  js  c++  java
  • 二叉树的遍历

    原文出自:http://blog.csdn.net/fantasy_lin_/article/details/52751559#

    1、分析

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

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

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

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

    深度优先

    英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止,而且每个节点只能访问一次。对于上面的例子来说深度优先遍历的结果就是:A,B,D,E,I,C,F,G,H.(假设先走子节点的的左侧)。

    深度优先遍历各个节点,需要使用到堆(Stack)这种数据结构。stack的特点是是先进后出。整个遍历过程如下:

    首先将A节点压入堆中,stack(A);

    将A节点弹出,同时将A的子节点C,B压入堆中,此时B在堆的顶部,stack(B,C);

    将B节点弹出,同时将B的子节点E,D压入堆中,此时D在堆的顶部,stack(D,E,C);

    将D节点弹出,没有子节点压入,此时E在堆的顶部,stack(E,C);

    将E节点弹出,同时将E的子节点I压入,stack(I,C);

    ...依次往下,最终遍历完成。

    广度优先

            英文缩写为BFS即Breadth FirstSearch。其过程检验来说是对每一层节点依次访问,访问完一层进入下一层,而且每个节点只能访问一次。对于上面的例子来说,广度优先遍历的 结果是:A,B,C,D,E,F,G,H,I(假设每层节点从左到右访问)。

           广度优先遍历各个节点,需要使用到队列(Queue)这种数据结构,queue的特点是先进先出,其实也可以使用双端队列,区别就是双端队列首位都可以插入和弹出节点。整个遍历过程如下:

          首先将A节点插入队列中,queue(A);

          将A节点弹出,同时将A的子节点B,C插入队列中,此时B在队列首,C在队列尾部,queue(B,C);

          将B节点弹出,同时将B的子节点D,E插入队列中,此时C在队列首,E在队列尾部,queue(C,D,E);

          将C节点弹出,同时将C的子节点F,G,H插入队列中,此时D在队列首,H在队列尾部,queue(D,E,F,G,H);

          将D节点弹出,D没有子节点,此时E在队列首,H在队列尾部,queue(E,F,G,H);

          ...依次往下,最终遍历完成。

    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);  
            }  
        }  
          
    }  
  • 相关阅读:
    PHP 5.5.0 Alpha5 发布
    Ubuntu Touch 只是另一个 Android 皮肤?
    MariaDB 10 已经为动态列提供文档说明
    Percona Toolkit 2.1.9 发布,MySQL 管理工具
    Oracle Linux 6.4 发布
    Ruby 2.0.0 首个稳定版本(p0)发布
    Apache Pig 0.11.0 发布,大规模数据分析
    Node.js 0.8.21 稳定版发布
    红薯 MySQL 5.5 和 5.6 默认参数值的差异
    Django 1.5 正式版发布,支持 Python 3
  • 原文地址:https://www.cnblogs.com/lingyejun/p/7153149.html
Copyright © 2011-2022 走看看