二叉树的遍历

二叉树的遍历分为前、中、后序遍历和层次遍历。

           图.1

创建树-程序代码：

public class Tree {
    private String data;
    private Tree lnode;
    private Tree rnode;
    private boolean isVisit;
    
    }

 

层次遍历：8 3 10 1 6 14 4 7 13

二叉树的层次遍历关键在于使用队列。

算法步骤：

1.加入根节点到队列中。

2.判断队列是否为空，为空转到7，非空转到3。

3.取出队列中队顶节点，打印

4.判断队顶元素的左孩子节点是否为空，如果非空，将该儿子节点加入到队列，如果为空，转到5。

5.判断队顶元素的右孩子节点是否为空，如果非空，将该儿子节点加入到队列，如果为空，转到6。

6.转到2。

7.结束。

程序代码：

/**
     * @author yin
     * 层次遍历
     */
    public void LevelTraversalOne(Tree node)
    {
        Queue<Tree> queue=new LinkedList<>();
        queue.add(node);
        Tree newNode;
        do
        {
            newNode=queue.peek();
            System.out.print(newNode.getData());
            queue.poll();
            if(newNode.getLnode()!=null)
            {
                queue.add(newNode.getLnode());
            }
            if(newNode.getRnode()!=null)
            {
                queue.add(newNode.getRnode());
            }
        }while(!queue.isEmpty());
    }

 

前序遍历：8 3 1 6 4 7 10 14 13

前序遍历主要有递归和非递归遍历，本节主要描述二叉树的前序非递归遍历。

算法步骤：

1.创建空栈。

2.令节点node指向根节点。

3.判断node是否为空，如果非空，转3；如果为空，转5。

4.打印node，将node加入栈中，并是node指向node的左儿子节点，转3

5.跳出循环。转向6。

6.判断栈是否为空，为空，转12，非空，转7.

7.令newNode指向栈顶节点，移除栈顶节点。

8.判断newNode的右儿子节点是否为空，如果非空，转向9，如果空，转6.

9.令rNode指向newNode的右儿子节点。

10.判断rNode是否为空，如果非空，转向11，如果为空，转向6；

11.打印rNode,并把rNode压入栈，令rNode指向rNode的左儿子节点。转10。

12.结束。

 

程序代码：

/**
     * @author yin
     * 前序遍历非递归
     * */
    public void beforeTraversal(Tree node)
    {
        Stack<Tree>  stack=new Stack<>();
        while(node!=null)
        {
            System.out.print(node.getData());
            stack.add(node);
            node=node.getLnode();
        }
        while(!stack.isEmpty())
        {
            Tree ts=stack.peek();
            stack.pop();
            if(ts.getRnode()!=null)
            {
                Tree lNode=ts.getRnode();
                while(lNode!=null)
                {
                    System.out.print(lNode.getData());
                    stack.add(lNode);
                    lNode=lNode.getLnode();
                }
            }
        }
    }

 

中序遍历和后序遍历类似前序遍历思想，不再详细叙述算法步骤，以下是程序代码。

/**
     * @author yin
     * 中序遍历非递归
     * */
    public void middleTraversal(Tree node)
    {
        Stack<Tree> stack=new Stack<>();
        while(node!=null)
        {
            stack.add(node);
            node=node.getLnode();
        }
        while(!stack.isEmpty())
        {
            Tree tr=stack.peek();
            System.out.print(tr.getData());
            stack.pop();
            if(tr.getRnode()!=null)
            {
                Tree rn=tr.getRnode();
                while(rn!=null)
                {
                    stack.add(rn);
                    rn=rn.getLnode();
                }
            }
        }
    }
    
    
    
    /**
     * @author yin
     * 后序遍历非递归
     * */
    public void afterTraversal(Tree node)
    {
        Stack<Tree> stack=new Stack<>();
        while(node!=null)
        {
            stack.add(node);
            node=node.getLnode();
        }
        while(!stack.isEmpty())
        {
            Tree tr=stack.peek();
            if(tr.getRnode()!=null&&tr.isVisit()==false)
            {
                tr.setVisit(true);
                Tree rn=tr.getRnode();
                while(rn!=null)
                {
                    stack.add(rn);
                    rn=rn.getLnode();
                }
            }
            else
            {
                System.out.print(tr.getData());
                stack.pop();
            }
        }
    }