8.4 树的遍历

1.递归先序遍历：

void PreOrder(BiTree T)
{
    if(T!=NULL)
    {
        visit(T);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }    
9 }

2.非递归先序遍历：

 void PreOrder2(BiTree T)
 {
      InitStack(S);
      BiTree p=T;
      while(p||!IsEmpty(S))
      {
          if(p)
          {
              visit(p->data);
             push(S,p);
             p=p->lchild;
         }
         else
         {
             pop(S,p);
             p=p->rchild;
         }
     }
 }

3.递归中序遍历：

void InOrder(BiTree T)
{
    if(T!=NULL)
    {
        InOrder(T->lchild);
        Visit(T);
        InOrder(T->rchild);
    }
}

4.非递归中序遍历：

 void InOrder2(BiTree T)
 {
     InitStack(S);
     BiTree p=T;
     while(p||!IsEmpty(S))
     {
         if(p)
         {
             Push(S,p);
             p=p->lchild;
         }
         else
         {
             Pop(S,p);
             visit(p);
             p=p->rchild;
         }
     }
 }

5.递归后序遍历：

void PostOrder(BiTree T)
{
    if(T!=NULL)
    {
        PostOrder(T->lchild);
        PostOrder(T->rchild);
        visit(T);
    }
}

6.非递归后序遍历：

 void PostOrder2(BiTree T)
 {
     InitStack(S);
     BiTree p=T;
     r=NULL;
     while(p||!IsEmpty(S))
     {
         if(p)
         {
             push(S,p);
             p=p->lchild;
         }
         else
         {
             GetTop(S,p);
             if(p->rchild&&p->rchild!=r)
             {
                 p=p->rchild;
                 push(S,p);
                 p=p->lchild;
             }
             else
             {
                 pop(S,p);
                 visit(p->data);
                 r=p;
                 p=NULL;
             }
         }
     }
 }

 

7.层次遍历：

 void LevelOrder(BiTree T)
 {
     InitQueue(Q);
     BiTree p;
     EnQueue(Q,T);
     while(!IsEmpty(Q))
     {
         DeQueue(Q,p);
         visit(p);
         if(p->lchild!=NULL)
             EnQueue(Q,p->lchild);
         if(p->rchild!=NULL)
             EnQueue(Q,p->rchild);
     }
 }

 

 

8.另一种写法风格：

 public static void preOrderUnRecur(Node head) {
     System.out.print("pre-order: ");
     if (head != null) {
         Stack<Node> stack = new Stack<Node>();
         stack.add(head);
         while (!stack.isEmpty()) {
             head = stack.pop();
             System.out.print(head.value + " ");
             if (head.right != null) {
                 stack.push(head.right);
             }
             if (head.left != null) {
                 stack.push(head.left);
             }
         }
     }
     System.out.println();
 }
 
 public static void inOrderUnRecur(Node head) {
     System.out.print("in-order: ");
     if (head != null) {
         Stack<Node> stack = new Stack<Node>();
         while (!stack.isEmpty() || head != null) {
             if (head != null) {
                 stack.push(head);
                 head = head.left;
             } else {
                 head = stack.pop();
                 System.out.print(head.value + " ");
                 head = head.right;
             }
         }
     }
     System.out.println();
 }
 
 public static void posOrderUnRecur1(Node head) {
     System.out.print("pos-order: ");
     if (head != null) {
         Stack<Node> s1 = new Stack<Node>();
         Stack<Node> s2 = new Stack<Node>();
         s1.push(head);
         while (!s1.isEmpty()) {
             head = s1.pop();
             s2.push(head);
             if (head.left != null) {
                 s1.push(head.left);
             }
             if (head.right != null) {
                 s1.push(head.right);
             }
         }
         while (!s2.isEmpty()) {
             System.out.print(s2.pop().value + " ");
         }
     }
     System.out.println();
 }
 
 public static void posOrderUnRecur2(Node h) {
     System.out.print("pos-order: ");
     if (h != null) {
         Stack<Node> stack = new Stack<Node>();
         stack.push(h);
         Node c = null;
         while (!stack.isEmpty()) {
             c = stack.peek();
             if (c.left != null && h != c.left && h != c.right) {
                 stack.push(c.left);
             } else if (c.right != null && h != c.right) {
                 stack.push(c.right);
             } else {
                 System.out.print(stack.pop().value + " ");
                 h = c;
             }
         }
     }  
     System.out.println();
 }