樹的三種遍歷（遞歸與非遞歸實現）

1：深度優先

1.1：前序遍歷

1. Visit the root.
2. Traverse the left subtree.
3. Traverse the right subtree.

如下圖：

Pre-order: F, B, A, D, C, E, G, I, H

僞代碼：

preorder(node) if node == null then return visit(node) preorder(node.left) preorder(node.right)

iterativePreorder(node) parentStack = empty stack parentStack.push(null) top = node while ( top != null ) visit( top ) if ( top.right != null ) parentStack.push(top.right) if ( top.left != null ) parentStack.push(top.left) top = parentStack.top(); parentStack.pop();

1.2：中序遍歷

1. Traverse the left subtree.
2. Visit root.
3. Traverse the right subtree.

In-order: A, B, C, D, E, F, G, H, I

僞代碼：

inorder(node) if node == null then return inorder(node.left) visit(node) inorder(node.right)

iterativeInorder(node) parentStack = empty stack while (not parentStack.isEmpty() or node ≠ null) if (node ≠ null) parentStack.push(node) node = node.left else node = parentStack.pop() visit(node) node = node.right

1.3：後序遍歷

1. Traverse the left subtree.
2. Traverse the right subtree.
3. Visit the root.

Post-order: A, C, E, D, B, H, I, G, F

僞代碼

postorder(node) if node == null then return postorder(node.left) postorder(node.right) visit(node)

iterativePostorder(node) parentStack = empty stack lastnodevisited = null while (not parentStack.isEmpty() or node ≠ null) if (node ≠ null) parentStack.push(node) node = node.left else peeknode = parentStack.peek() if (peeknode.right ≠ null and lastnodevisited ≠ peeknode.right) /* if right child exists AND traversing node from left child, move right */ node = peeknode.right else parentStack.pop() visit(peeknode) lastnodevisited = peeknode

1.4：java代碼實現三種遍歷

樹的結構是

                                            10
                                           /   \
                                          5     12
                                        /   \   
                                     4       7 

代碼中我主要解釋下讓我一直糾結的遞歸法了，總是對遞歸法執行的順序有疑惑。詳細可以看《Thinking In Algorithm》09.徹底理解遞歸

public class Preorder{
    /*******************************遞歸法****************************/
    //遞歸前序遍歷        print：10,5,4,7,12
    public static void preorder(TNode node){
        if(node!=null){
            System.out.println(node.getValue()) ;
            preorder(node.getLeft()) ;
            preorder(node.getRight()) ;
        }
    }
    //遞歸中序遍歷        print: 4,5,7,10,12
    public static void inorder(TNode node){
        if(node!=null){
            inorder(node.getLeft()) ;
            System.out.println(node.getValue()) ;
            inorder(node.getRight()) ;
        }
    }
    //遞歸後序遍歷        print: 4,7,5,12,10
    public static void postorder(TNode node){
        if(node!=null){
            postorder(node.getLeft()) ;
            postorder(node.getRight()) ;
            System.out.println(node.getValue()) ;
        }
    }

    /*******************************非遞歸*****************************/
    //非遞歸前序遍歷       print：10,5,4,7,12
    public static void iterativePreorder(TNode node){
        MyStack parentStack = new MyStack() ;
        parentStack.push(node) ;
        while(!parentStack.isEmpty()){
            TNode temp = parentStack.getFirst().getValue() ;
            System.out.println(temp.getValue()) ;
            parentStack.pop() ;
            if(temp.getRight()!=null){ parentStack.push(temp.getRight()) ;}
            if(temp.getLeft()!=null){ parentStack.push(temp.getLeft()) ;}
        }
    }
    //非遞歸中序遍歷       print: 4,5,7,10,12
    public static void iterativeInorder(TNode node){
        MyStack  mystack = new MyStack() ;
        while(!mystack.isEmpty()||node!=null){
            if(node!=null){
                mystack.push(node) ;
                node = node.getLeft() ;
            }else{
                node = mystack.pop().getValue() ;
                System.out.println(node.getValue()) ;
                node = node.getRight() ;
            }
        }
    }
    //非遞歸後序遍歷       print: 4,7,5,12,10
    public static void iterativePostorder(TNode node){
        MyStack  mystack = new MyStack() ;
        TNode temp = null ;
        TNode peeknode = null ;
        while(!mystack.isEmpty()||node!=null){
            if(node!=null){
                mystack.push(node) ;
                node = node.getLeft() ;
            }else{
                peeknode = mystack.getFirst().getValue() ;
                if(peeknode.getRight()!=null&&temp!=peeknode.getRight()){
                    node = peeknode.getRight() ;
                }else{
                    mystack.pop() ;
                    System.out.println(peeknode.getValue()) ;
                    temp = peeknode ;
                }
            }
        }
    }

    public static void main(String args[]){
        MyTree mytree = new MyTree() ;
        mytree.insert(10) ;
        mytree.insert(5);
        mytree.insert(12);
        mytree.insert(4);
        mytree.insert(7);

        preorder(mytree.getRoot()) ;
        inorder(mytree.getRoot()) ;
        postorder(mytree.getRoot()) ;

        iterativePreorder(mytree.getRoot()) ;
        iterativeInorder(mytree.getRoot()) ;
        iterativePostorder(mytree.getRoot()) ;
    }
}
/*****************二叉樹的實現****************/
class TNode{
    private int value ;
    private TNode left ;
    private TNode right ;

    public TNode(int value){ this.value = value ;}
    public void setLeft(int value){ this.left = new TNode(value) ;}
    public void setRight(int value){ this.right = new TNode(value) ;}
    public TNode getLeft(){ return this.left ;}
    public TNode getRight(){ return this.right ;}
    public int getValue(){ return this.value ;}
}
class MyTree{
    private TNode root ;

    public void setRoot(int value){ this.root = new TNode(value) ;}
    public TNode getRoot(){ return this.root ;}
    public void insert(int value){
        TNode x = this.root ;
        TNode y = null ;
        while(x!=null){
            y = x ;
            if(value<x.getValue()){ x = x.getLeft() ;}
            else{ x = x.getRight() ;}
        }

        if(y == null){ setRoot(value) ;}
        else if(value<y.getValue())
        { y.setLeft(value) ;}
        else{ y.setRight(value) ;}
    }
}

/*****************棧的實現****************/
class StackNode{
        public TNode item ;
        public StackNode next ;

        public StackNode(){ ;}
        public StackNode(TNode item){ this.item = item ;}
        public TNode getValue(){ return item ;}
}
class MyStack{
    int N ; //size of myStack
    StackNode first ; // the top of stack


    //size of mystack
    public int size(){ return N ;}

    //empty or not
    public boolean isEmpty(){ return N==0 ;}

    public StackNode getFirst(){ return this.first ;}

    public void push(TNode item){
        if(isEmpty()){
            first = new StackNode() ;
            first.item = item;
            N++;
        }else{
            StackNode oldfirst = first;
            first = new StackNode() ;
            first.item = item;
            first.next = oldfirst;
            N++;
        }

    }
    public StackNode pop(){
        StackNode top = first ;
        first = first.next;            // delete first node
        N--;
        return top ;
    }
}

2.廣度遍歷

廣度遍歷比較簡單，就是層次遍歷

                

僞代碼

levelorder(root)
  q = empty queue
  q.enqueue(root)
  while not q.empty do
    node := q.dequeue()
    visit(node)
    if node.left ≠ null then
      q.enqueue(node.left)
    if node.right ≠ null then
      q.enqueue(node.right)