二叉树的非递归遍历(java实现)

二叉树的创建

树的定义

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 * }
 */

二叉树的创建

public static TreeNode Create(){
     String str=scan.next();
     char c=str.charAt(0);
     TreeNode root;
     if(c=='^'){
         root=null;
     }else{
         root=new TreeNode();
         root.val=c;
         root.left=Create();
         root.right=Create();
     }
     return root;
}

树的遍历

树遍历的相关内容

(1)什么是二叉树的遍历？
   指按某种规律对二叉树的每个结点进行访问且仅访问一次的过程。
(2)从另一个方面来说，遍历操作就是将二叉树中的结点按一定的规律进行线性化的操作，将非线性化结构变成线性化的访问序列。 
(3)二叉树遍历的重要性？
   二叉树遍历是对二叉树进行多种运算操作的基础。

前序非递归

下面两段代码虽然书写形式不同，但是实现功能是相同的。
这两种写法对中序，后序遍历同样适用。

public List<Integer> preorderTraversal(TreeNode root) {
      List<Integer> list=new ArrayList<Integer>();
      Stack<TreeNode> stack=new Stack<TreeNode>();
      TreeNode t=root;
      while(t!=null || stack.size()!=0){
          while(t!=null){  
              list.add(t.val);
              stack.push(t);
              t=t.left;
          }
          if(stack.size()!=0){
              TreeNode node=stack.pop();
              t=node.right;
          }
      }
      return list;
}

public List<Integer> preorderTraversal(TreeNode root) {
     List<Integer> list=new ArrayList<Integer>();
     Stack<TreeNode> stack=new Stack<TreeNode>();
     TreeNode t=root;
     while(t!=null || stack.size()!=0){
         if(t!=null){  
             list.add(t.val);
             stack.push(t);
             t=t.left;
         }else{
             TreeNode node=stack.pop();
             t=node.right;
         }
     }
     return list;
}

中序非递归

public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> list=new ArrayList<Integer>();
    Stack<TreeNode> stack=new Stack<TreeNode>();
    TreeNode t=root;
    while(t!=null || stack.size()!=0){
        while(t!=null){
            stack.push(t);
            t=t.left;
        }
        if(stack.size()!=0){
            TreeNode node=stack.pop();
            list.add(node.val);
            t=node.right;
        }
    }
    return list;
}

后序非递归

//在后序遍历时，左右子树均访问完成后，从右子树返回时，上层结点才能退栈并被访问 
public List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> list=new ArrayList<Integer>();
    Stack<TreeNode> stack=new Stack<TreeNode>();
    TreeNode t=root;
    TreeNode now=null;         //始终记录刚访问过的结点
    while(t!=null || stack.size()!=0){
        while(t!=null){
            stack.push(t);
            t=t.left;
        }
        if(stack.size()!=0){
            //当前的栈顶元素
            TreeNode node=stack.peek();
            if(node.right==null || node.right==now){
                stack.pop();
                list.add(node.val);
                now=node;
            }else{
                t=node.right;
            }
        }
    }
    return list;
}

层次遍历

public static void be(TreeNode root){
   Queue<TreeNode> queue=new LinkedList<TreeNode>();
   queue.offer(root);
   while(queue.size()!=0){
       TreeNode node=queue.poll();
       System.out.print(node.val);
       if(node.left!=null)
           queue.offer(node.left);
       if(node.right!=null)
           queue.offer(node.right);
   }
}

复杂度的比较

算法类型	时间复杂度	空间复杂度
递归	大于非递归	大于非递归
非递归	O(n)	O(k)

O(n)：设有n个结点，访问每个结点的时间为常量级。
O(k)：所需的栈空间和二叉树深度k成正比。