数据结构与算法（二）二叉树

关于二叉树的遍历
递归实现特别简单。。。
再次强调，所谓的序指的是根节点位置。

这里给出实现和结果

package offer.tree;
class Node{
    Node lchild;
    Node rchild;
    char value;
    public Node(Node lchild,Node rchild,char value){
        this.lchild=lchild;
        this.rchild=rchild;
        this.value=value;
    }
}
public class BLtree {
    public static void preBL(Node n){
        if(n==null){
            return;
        }
        System.out.print(n.value);
        preBL(n.lchild);
        preBL(n.rchild);
    }
    public static void zhongBL(Node n){
        if(n==null){
            return;
        }
        zhongBL(n.lchild);
        System.out.print(n.value);
        zhongBL(n.rchild);
    }
    public static void houBL(Node n){
        if(n==null){
            return;
        }
        houBL(n.lchild);
        houBL(n.rchild);
        System.out.print(n.value);
    }
    public static void main(String[] args) {
        Node d=new Node(null,null,'D');
        Node e=new Node(null,null,'E');
        Node f=new Node(null,null,'F');
        Node c=new Node(f,null,'C');
        Node b=new Node(d,e,'B');
        Node a=new Node(b,c,'A');
        System.out.println("前序遍历：");
        preBL(a);
        System.out.println("\n中序遍历：");
        zhongBL(a);
        System.out.println("\n后序遍历: ");
        houBL(a);
    }
}

前序遍历：
ABDECF
中序遍历：
DBEAFC
后序遍历:
DEBFCA

前序的非递归实现，利用栈，先进后出

//用栈结构实现前序遍历,先进的后出，所以先压右子树
用到栈了，得想清楚，遍历的具体过程
    public static void preBLbyStack(Node n){
        Stack<Node> stack=new Stack<Node>();
        stack.push(n);
        while (!stack.isEmpty()){
            Node now=stack.pop();
            System.out.print(now.value);
            if(now.rchild!=null){
                stack.push(now.rchild);
            }
            if(now.lchild!=null){
                stack.push(now.lchild);
            }
        }
    }

中序的非递归实现

//描述一下中序遍历的过程，首先找左子树，一直找到最左叶子节点，输出，然后输出根，
    // 再遍历该根下的右子树，情况如同上面一样。
    public static void zhongBLbyStack(Node n){
        Stack<Node> stack=new Stack<Node>();
        while(n!=null||stack.size()>0){
            if(n!=null){
                stack.push(n);
                n=n.lchild;
            }else {
                n=stack.pop();
                System.out.print(n.value);
                n=n.rchild;
            }
        }
    }

后序的非递归实现

//先一直找最左节点，然后找该节点的父节点的右子树
    //依然重复上述过程
    public static void houBLbyStack(Node n){
        if(n==null){
            return;
        }
        Node p=n;
        Stack<Node> stack=new Stack<Node>();
        while (p!=null||!stack.isEmpty()){
            if(p!=null){
                stack.push(p);
                p=p.lchild;
            }else {
                Node now=stack.pop();
                //这里可能得到父节点或者右子树
                if(now.rchild==null||now.rchild==n){
                    //如果当前节点没有右子树，可以输出
                    //如果有右子树，但右子树已经遍历完成，也可以输出，即now.rchild==最近刚输出的节点n
                    System.out.print(now.value);
                    n=now;
                    //输出完成后，由于当前节点不为空，会进行左子树进栈，所以将判断节点 p=null
                    p=null;
                }else {
                    //右子树不为空，所以再把父节点push回去
                    stack.push(now);
                   //这一步是为了把右子树根push进栈
                    p=now.rchild;
                }
            }
        }
    }

层次遍历：即按从左往右，从上往下一层一层的遍历，该图结果为ABCDEF

放到广搜和深搜里去吧。

说一下做选择题的技巧：
前序序列的特点：第一个节点是根
中序序列的特点：根节点左右两边是左子树和右子树
后序序列的特点：最后一个节点是根