【转】二叉树

package foo;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * 创建树的文件内容，例如树<pre>
 *               A
 *           B        C
 *        D         E     
 * </pre>
 * 就是其先序序列：A B D # # # C E # # #
 * 其中第1、2个#是D的左右子节点（空），滴3个#是B的右子节点（空），第4、5个#是
 * E的左右子节点（空），第6个#是C的右子节点（空）
 * */

/**
 * 仅作演示使用 
 * */
class Tree {
    
    // 在eclipse 中创建的普通java项目，所以路径是这么写的
    private static final String filePath = "bin/foo/input.txt";

    private Node<String> root;
    
    public Tree() {
    }
    
    public Tree(Node<String> root) {
        this.root = root;
    }
    
    //创建二叉树
    public void buildTree() {
        
        Scanner scn = null;
        try {
            scn = new Scanner(new File(filePath));
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return;
        }
        root = createTree(root,scn);        
    }
    
    // 先序遍历创建二叉树（递归）
    private Node<String> createTree(Node<String> node,Scanner scn) {
        
        String temp  = scn.next();
        
        if (temp.trim().equals("#")) {
            return null;
        } else {
            node = new Node<String>(temp);
            node.setLeft(createTree(node.getLeft(), scn));
            node.setRight(createTree(node.getRight(), scn));
            return node;
        }
    }
    
    
    
    //中序遍历(递归)
    public void inOrderTraverse() {
        inOrderTraverse(root);
    }
    
    public void inOrderTraverse(Node<String> node) {
        if (node != null) {
            inOrderTraverse(node.getLeft());
            System.out.println(node.getValue());
            inOrderTraverse(node.getRight());
        }
    }
    
    
    //中序遍历(非递归)
    public void nrInOrderTraverse() {
        
        Stack<Node<String>> stack = new Stack<Node<String>>();
        Node<String> node = root;
        while (node != null || !stack.isEmpty()) {
            while (node != null) {
                stack.push(node);
                node = node.getLeft();
            }
            node = stack.pop();
            System.out.println(node.getValue());
            node = node.getRight();
            
        }
                
    }
    //先序遍历(递归)
    public void preOrderTraverse() {
        preOrderTraverse(root);
    }
    
    public void preOrderTraverse(Node<String> node) {
        if (node != null) {
            System.out.println(node.getValue());
            preOrderTraverse(node.getLeft());
            preOrderTraverse(node.getRight());
        }
    }
    
    
    //先序遍历（非递归）
    public void nrPreOrderTraverse() {
        
        Stack<Node<String>> stack = new Stack<Node<String>>();
        Node<String> node = root;
        
        while (node != null || !stack.isEmpty()) {
            
            while (node != null) {
                System.out.println(node.getValue());
                stack.push(node);
                node = node.getLeft();
            }
            node = stack.pop();
            node = node.getRight();
        }    
    }
    
    //后序遍历(递归)
    public void postOrderTraverse() {
        postOrderTraverse(root);
    }
    
    public void postOrderTraverse(Node<String> node) {
        if (node != null) {
            postOrderTraverse(node.getLeft());
            postOrderTraverse(node.getRight());
            System.out.println(node.getValue());
        }
    }
    
    //后续遍历(非递归)
    public void nrPostOrderTraverse() {
        
        Stack<Node<String>> stack = new Stack<Node<String>>();
        Node<String> node = root;
        Node<String> preNode = null;//表示最近一次访问的节点
        
        while (node != null || !stack.isEmpty()) {
            
            while (node != null) {
                stack.push(node);
                node = node.getLeft();
            }
            
            node = stack.peek();
            
            if (node.getRight() == null || node.getRight() == preNode) {
                System.out.println(node.getValue());
                node = stack.pop();
                preNode = node;
                node = null;
            } else {
                node = node.getRight();
            }
            
        }
        
        
        
        
    }
    
    //按层次遍历
    public void levelTraverse() {
        levelTraverse(root);
    }
    
    public void levelTraverse(Node<String> node) {
    
        Queue<Node<String>> queue = new LinkedBlockingQueue<Node<String>>();
        queue.add(node);
        while (!queue.isEmpty()) {
            
            Node<String> temp = queue.poll();
            if (temp != null) {
                System.out.println(temp.getValue());
                queue.add(temp.getLeft());
                queue.add(temp.getRight());
            }
                        
        }
                
    }
    
    
    
    
}



//树的节点

class Node<T> {
    
    private Node<T> left;
    private Node<T> right;
    private T value;
    
    public Node() {
    }
    public Node(Node<T> left,Node<T> right,T value) {
        this.left = left;
        this.right = right;
        this.value = value;
    }
    
    public Node(T value) {
        this(null,null,value);
    }
    public Node<T> getLeft() {
        return left;
    }
    public void setLeft(Node<T> left) {
        this.left = left;
    }
    public Node<T> getRight() {
        return right;
    }
    public void setRight(Node<T> right) {
        this.right = right;
    }
    public T getValue() {
        return value;
    }
    public void setValue(T value) {
        this.value = value;
    }
        
}


public class Main {
    
    /**
     * 二分查找
     * @param key 搜索的目标
     * */
    private static int binarySearch(int[] a, int fromIndex, int toIndex, int key) {
        int low = fromIndex;
        int high = toIndex - 1;
        int mid, midVal;
        while (low <= high) {
            mid = (low + high) >>> 1;
            midVal = a[mid];
            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }
    
    public static void swap(int[] a, int index1, int index2) {
        int temp = a[index1];
        a[index1] = a[index2];
        a[index2] = temp;
    }
    
    public static void main(String[] args) {
        Tree tree = new Tree();
        tree.buildTree();
        System.out.println("中序遍历（递归）");
        tree.inOrderTraverse();
        System.out.println("中序遍历（非递归）");
        tree.nrInOrderTraverse();
        System.out.println("后续遍历（递归）");
        tree.postOrderTraverse();
        System.out.println("后续遍历（非递归）");
        tree.nrPostOrderTraverse();
        System.out.println("先序遍历（递归）");
        tree.preOrderTraverse();
        System.out.println("先序遍历（非递归）");
        tree.nrPreOrderTraverse();
    }
}

二叉树的遍历有三种方式，如下：

（1）前序遍历（DLR），首先访问根结点，然后遍历左子树，最后遍历右子树。简记根-左-右。

（2）中序遍历（LDR），首先遍历左子树，然后访问根结点，最后遍历右子树。简记左-根-右。

（3）后序遍历（LRD），首先遍历左子树，然后遍历右子树，最后访问根结点。简记左-右-根。

例1：如上图所示的二叉树，若按前序遍历，则其输出序列为      。若按中序遍历，则其输出序列为      。若按后序遍历，则其输出序列为      。

　　前序：根A，A的左子树B，B的左子树没有，看右子树，为D，所以A-B-D。再来看A的右子树，根C，左子树E，E的左子树F，E的右子树G，G的左子树为H，没有了结束。连起来为C-E-F-G-H,最后结果为ABDCEFGH

　　中序：先访问根的左子树,B没有左子树，其有右子树D，D无左子树，下面访问树的根A，连起来是BDA。

　　再访问根的右子树，C的左子树的左子树是F，F的根E，E的右子树有左子树是H，再从H出发找到G，到此C的左子树结束，找到根C，无右子树，结束。连起来是FEHGC,  中序结果连起来是BDAFEHGC

　　后序：B无左子树，有右子树D，再到根B。再看右子树，最下面的左子树是F，其根的右子树的左子树是H，再到H的根G，再到G的根E，E的根C无右子树了，直接到C，这时再和B找它们其有的根A，所以连起来是DBFHGECA

例2:有下列二叉树，对此二叉树前序遍历的结果为（    ）。

A）ACBEDGFH                                          B）ABDGCEHF

C）HGFEDCBA                                          D）ABCDEFGH

解析：先根A，左子树先根B，B无左子树，其右子树，先根D，在左子树G，连起来是ABDG。 A的右子树，先根C，C左子树E，E无左子树，有右子树为H，C的右子树只有F，连起来是CEHF。整个连起来是B答案 ABDGCEHF。

例3：已知二叉树后序遍历是DABEC，中序遍历序列是DEBAC，它的前序遍历序列是(       )  。

A）CEDBA  B）ACBED C）DECAB D）DEABC

解析：由后序遍历可知，C为根结点，由中序遍历可知，C左边的是左子树含DEBA，C右边无结点，知根结点无右子树。先序遍历先访问根C，答案中只有A以C开头，为正确答案。

例4：  如下二叉树中序遍历的结果是（　　）。

A). ACBDFEG  B). ACBDFGE  C).ABDCGEF  D).FCADBEG

解析:首先中序遍历根F会把左右子树分开，F不会在答案的开头和结尾，排除C和D。在看F的右子树，G是E的右子树，中序遍历先访问E，再访问G，E在G前面，排除B。答案为A。

 

例5：如下二叉树后序遍历的结果是（　　）。

A)  ABCDEF  B) DBEAFC  C)ABDECF  D)DEBFCA

解析：后序的最后一个必须是二叉树的根，快速判断答案为D。