java二叉树的几种遍历递归与非递归实现代码

前序（先序）遍历
中序遍历
后续遍历
层序遍历

如图二叉树：

二叉树结点结构

public class treenode {
  int val;
  treenode left;
  treenode right;
  treenode(int x){
    val=x;
  }
  @override
  public string tostring(){
    return "val: "+val;
  }
}

访问函数

  public void visit(treenode node){
    system.out.print(node.val+" ");
  }

前序遍历

对于图中二叉树而言其前序遍历结果为：6 2 0 1 4 5 8 9
二叉树的前序遍历即先遍历根结点再遍历左结点最后遍历右结点，使用递归如下：

  /**
   * 递归先序遍历
   * */
  public void preorderrecursion(treenode node){
    if(node==null) //如果结点为空则返回
      return;
    visit(node);//访问根节点
    preorderrecursion(node.left);//访问左孩子
    preorderrecursion(node.right);//访问右孩子
  }

非递归：

利用栈来实现二叉树的先序非递归遍历

  /**
   * 非递归先序遍历二叉树
   * */
  public list<integer> preordertraversal(treenode root) {
    list<integer> resultlist=new arraylist<>();
    stack<treenode> treestack=new stack<>();
    if(root==null) //如果为空树则返回
      return resultlist;
    treestack.push(root);
    while(!treestack.isempty()){
      treenode tempnode=treestack.pop(); 
      if(tempnode!=null){
        resultlist.add(tempnode.val);//访问根节点
        treestack.push(tempnode.right); //入栈右孩子
        treestack.push(tempnode.left);//入栈左孩子
      }
    }
    return resultlist;
  }

更新：评论里有人说不理解非递归的先序遍历，其实你举个例子，然后画个图就可以理解了，以上图中的二叉树为例，先将6入栈，此时list为空，stack只有一个元素6，进入while循环，弹出栈顶加入list，将6的右孩子和左孩子入栈，此时stack从栈底到栈顶元素为8,2，list元素为6，由于栈不为空，进入while循环，弹出栈顶2,将2加入list,同时将2的右孩子和左孩子分别入栈，此时stack从栈底到栈顶的元素为8,4,0, list的元素为6,2，由于栈不为空再次进入while循环…依次下去，弹出0加入list，入栈1,null，此时stack从栈底到栈顶为8,4,1,null，list为6,2,0，弹出null为空继续弹出1，如此下去就可以了…

中序遍历

对于二叉树的中序遍历，即先访问左结点再访问根节点最后访问右结点

递归方法如下：

  /**
   * 递归中序遍历
   * */
  public void preorderrecursion(treenode node){
    if(node==null) //如果结点为空则返回
      return;
    preorderrecursion(node.left);//访问左孩子
    visit(node);//访问根节点
    preorderrecursion(node.right);//访问右孩子
  }

非递归：

在上图中的二叉树，其中序遍历为：0 1 2 4 5 6 8 9
可以看到，二叉树的中序遍历如下：
先将根节点入栈，
一直往其左孩子走下去，将左孩子入栈，直到该结点没有左孩子，则访问这个结点，如果这个结点有右孩子，则将其右孩子入栈，重复找左孩子的动作，这里有个要判断结点是不是已经被访问的问题。
非递归中序遍历（效率有点低），使用map（用set貌似更合理）来判断结点是否已经被访问

  /**
   * 非递归中序遍历
   * */
  public list<integer> inordertraversalnoncur(treenode root) {
    list<integer> visitedlist=new arraylist<>();
    map<treenode,integer> visitednodemap=new hashmap<>();//保存已访问的节点
    stack<treenode> tobevisitednodes=new stack<>();//待访问的节点
    if(root==null)
      return visitedlist;
    tobevisitednodes.push(root);
    while(!tobevisitednodes.isempty()){
      treenode tempnode=tobevisitednodes.peek(); //注意这里是peek而不是pop
      while(tempnode.left!=null){ //如果该节点的左节点还未被访问，则需先访问其左节点
        if(visitednodemap.get(tempnode.left)!=null) //该节点已经被访问（不存在某个节点已被访问但其左节点还未被访问的情况）
          break;
        tobevisitednodes.push(tempnode.left);
        tempnode=tempnode.left;
      }
      tempnode=tobevisitednodes.pop();//访问节点
      visitedlist.add(tempnode.val);
      visitednodemap.put(tempnode, 1);//将节点加入已访问map
      if(tempnode.right!=null) //将右结点入栈
        tobevisitednodes.push(tempnode.right);
    }
    return visitedlist;
  }

discuss中有人给出更简洁的方法

public list<integer> inordertraversal(treenode root) {
  list<integer> list = new arraylist<integer>();

  stack<treenode> stack = new stack<treenode>();
  treenode cur = root;

  while(cur!=null || !stack.empty()){
    while(cur!=null){
      stack.add(cur);
      cur = cur.left;
    }
    cur = stack.pop();
    list.add(cur.val);
    cur = cur.right;
  }

  return list;
}

后序遍历

递归代码就不贴了

如果之前的非递归中序遍历使用map的方法理解后，后序遍历的话我们也可以使用一个map来保存那些已经被访问的结点，后序遍历即先访问左孩子再访问右孩子最后访问根结点。
非递归代码：

  /**
   * 非递归后序遍历
   * */
  public list<integer> postordernoncur(treenode root){
    list<integer> resultlist=new arraylist<>();
    if(root==null)
      return resultlist;
    map<treenode,integer> visitedmap=new hashmap<>();
    stack<treenode> tobevisitedstack=new stack<>();
    tobevisitedstack.push(root);
    while(!tobevisitedstack.isempty()){
      treenode tempnode=tobevisitedstack.peek(); //注意这里是peek而不是pop
      if(tempnode.left==null && tempnode.right==null){ //如果没有左右孩子则访问
        resultlist.add(tempnode.val);
        visitedmap.put(tempnode, 1);
        tobevisitedstack.pop();
        continue;
      }else if(!((tempnode.left!=null&&visitedmap.get(tempnode.left)==null )|| (tempnode.right!=null && visitedmap.get(tempnode.right)==null))){
        //如果节点的左右孩子均已被访问      
        resultlist.add(tempnode.val);
        tobevisitedstack.pop();
        visitedmap.put(tempnode, 1);
        continue;
      }
      if(tempnode.left!=null){
        while(tempnode.left!=null && visitedmap.get(tempnode.left)==null){//左孩子没有被访问
          tobevisitedstack.push(tempnode.left);
          tempnode=tempnode.left;
        }
      }
      if(tempnode.right!=null){
        if(visitedmap.get(tempnode.right)==null){//右孩子没有被访问
          tobevisitedstack.push(tempnode.right);
        }        
      }
    }
    return resultlist;
  }

discuss中有人给出了一个”巧“的方法，即先采用类似先序遍历，先遍历根结点再右孩子最后左孩子（先序是先根结点再左孩子最后右孩子），最后把遍历的序列逆转即得到了后序遍历

public list<integer> postordertraversal(treenode root) {
  deque<treenode> stack = new linkedlist<>();
  stack.push(root);
  list<integer> ret = new arraylist<>();
  while (!stack.isempty()) {
    treenode node = stack.pop();
    if (node != null) {
      ret.add(node.val);
      stack.push(node.left);
      stack.push(node.right);
    }
  }
  collections.reverse(ret);
  return ret;
} 

层序遍历

层序遍历也即宽度优先搜索，一层一层搜索，非递归代码如下：

  public list<list<integer>> levelorder(treenode root) {
    list<list<integer>> resultlist=new arraylist<>();
    int levelnum=0;//记录某层具有多少个节点
    queue<treenode> treequeue=new linkedlist<>();
    treequeue.add(root);
    while(!treequeue.isempty()){
      levelnum=treequeue.size();
      list<integer> levellist=new arraylist<>();
      while(levelnum>0){
        treenode tempnode=treequeue.poll();
        if(tempnode!=null){
          levellist.add(tempnode.val);
          treequeue.add(tempnode.left); 
          treequeue.add(tempnode.right);
        }
        levelnum--;
      }
      if(levellist.size()>0) 
        resultlist.add(levellist);
    }
    return resultlist;    
  }

到此这篇关于java二叉树的几种遍历递归与非递归实现代码的文章就介绍到这了,更多相关java二叉树内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！