二叉树的非递归遍历：Java语言实现

最新推荐文章于 2024-08-12 18:57:34 发布
最新推荐文章于 2024-08-12 18:57:34 发布
阅读量617 收藏 9
点赞数 1
分类专栏： 数据结构与算法 文章标签： 二叉树 非递归遍历 数据结构 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cqulun123/article/details/80379101
版权

1 前言

       上一篇写了《二叉树的递归遍历：Java语言实现》，现在用java实现下二叉树的非递归遍历。

2 二叉树的非递归遍历

2.1 先序遍历

       根据前序遍历访问的顺序，优先访问根结点，然后再分别访问左孩子和右孩子。即对于任一结点，其可看做是根结点，因此可以直接访问。访问完之后，若其左孩子不为空，按相同规则访问它的左子树；当访问其左子树时，再访问它的右子树。因此其处理过程如下：
对于任一结点P：
1)将结点P入栈，并访问结点P;
2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);若不为空，则将P的左孩子置为当前的结点P;
3)直到P为NULL并且栈为空，则遍历结束。

//先序遍历:非递归方法
    public void PreOrderIterative(BinaryTreeNode root) {
        BinaryTreeNode temp = root;
        Stack<BinaryTreeNode> s = new Stack<BinaryTreeNode>();
        while (temp != null || !s.isEmpty()) {
            while (temp != null) {  //遇到一个结点，就把它压栈并访问它，然后去遍历它的左子树；
                s.push(temp);
                System.out.print(temp.getData() + " ");
                temp = temp.getLeft();
            }
            if(!s.isEmpty()) {
                temp = s.pop();//当左子树遍历结束后，从栈顶弹出这个结点；
                temp = temp.getRight();//然后按其右指针再去先序遍历该结点的右子树
            }
        }
    }

2.2 中序遍历

       根据中序遍历的顺序，对于任一结点，优先访问其左孩子，而左孩子结点又可以看做一根结点，然后继续访问其左孩子结点，直到遇到左孩子结点为空的结点才进行访问，然后按相同的规则访问其右子树。因此其处理过程如下：
对于任一结点P，
1)若其左孩子不为空，则将P入栈并将P的左孩子置为当前的P，然后对当前结点P再进行相同的处理；
2)若其左孩子为空，则取栈顶元素并进行出栈操作，访问该栈顶结点，然后将当前的P置为栈顶结点的右孩子；

3)直到P为NULL并且栈为空则遍历结束

//中序遍历:非递归方法
    public void InOrderIterative(BinaryTreeNode root) {
        BinaryTreeNode temp = root;
        Stack<BinaryTreeNode> s = new Stack<BinaryTreeNode>();
        while (temp != null || !s.isEmpty()) {
            while (temp != null) {  //遇到一个结点，就把它压栈，并去遍历它的左子树；
                s.push(temp);
                temp = temp.getLeft();
            }
            if(!s.isEmpty()) {
                temp = s.pop();//当左子树遍历结束后，从栈顶弹出这个结点并访问它；
                System.out.print(temp.getData() + " ");
                temp = temp.getRight();// 然后按其右指针再去中序遍历该结点的右子树
            }
        }
    }

2.3 后序遍历

       首先要搞清楚先序、中序、后序的非递归算法共同之处：用栈来保存先前走过的路径，以便可以在访问完子树后,可以利用栈中的信息,回退到当前节点的双亲节点,进行下一步操作。
       后序遍历的非递归算法是三种顺序中最复杂的，原因在于，后序遍历是先访问左、右子树,再访问根节点，而在非递归算法中，利用栈回退到时，并不知道是从左子树回退到根节点，还是从右子树回退到根节点，如果从左子树回退到根节点，此时就应该去访问右子树，而如果从右子树回退到根节点，此时就应该访问根节点。所以相比前序和后序，必须得在压栈时添加信息，以便在退栈时可以知道是从左子树返回，还是从右子树返回进而决定下一步的操作。

这里采取的做法为：引入一个pre指针，标记访问当前节点的之前访问的节点。如果root.right为pre，或者root.right为null，则可以判断已经从右子树访问返回。

//后序遍历:非递归方法
    public void PostOrderIterative(BinaryTreeNode root) {
        BinaryTreeNode temp = root;
        BinaryTreeNode pre = null;//标记访问序列中前一个二叉树节点（当前节点的之前访问的节点）
        Stack<BinaryTreeNode> s = new Stack<BinaryTreeNode>();
        while (temp != null || !s.isEmpty()) {
            while (temp != null) {
                s.push(temp);
                temp = temp.getLeft();
            }
            if(!s.isEmpty()) {
                temp = s.peek();
                //如果一个节点右孩子是空，或者右孩子刚被访问过，那么就访问该节点。否则就往右孩子走。
                if(temp.getRight() == null || temp.getRight() == pre) {
                    System.out.print(temp.getData() + " ");
                    s.pop();
                    pre = temp;
                    temp = null;
                }else {
                    temp = temp.getRight();
                }
        }
        }
    }

2.4 层序遍历

层序遍历的基本过程：

1. 先根节点入队
2. 队列不为空，从队列中取出一个元素
3. 访问该元素所指的结点
4. 若该元素所指结点的左、右孩子结点非空，则将其左、右孩子顺序入队

//层序遍历
    public void LevelOrder(BinaryTreeNode root) {
        BinaryTreeNode temp;
        Queue<BinaryTreeNode> q = new LinkedList<BinaryTreeNode>();
        if(root == null)
            return;
        q.add(root);
        while (!q.isEmpty()) {
            temp = q.poll();//移除并返问队列头部的元素
            System.out.print(temp.getData() + " ");
            if (temp.getLeft() != null) {
                q.add(temp.getLeft());//左孩子入队
            }
            if (temp.getRight() != null) {
                q.add(temp.getRight());//右孩子入队
            }
        }
    }

3 整体代码实现

3.1 建立二叉树结点类

package Binary_Tree_Study;

/**
 * Created by Administrator on 2018/5/19.
 */
public class BinaryTreeNode {
    private int data;//结点的数据
    private BinaryTreeNode left;//指向左孩子结点
    private BinaryTreeNode right;//指向左孩子结点

    public BinaryTreeNode(int data) {
        this.data = data;
        this.left = null;
        this.right =null;
    }

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public BinaryTreeNode getLeft() {
        return left;
    }

    public void setLeft(BinaryTreeNode left) {
        this.left = left;
    }

    public BinaryTreeNode getRight() {
        return right;
    }

    public void setRight(BinaryTreeNode right) {
        this.right = right;
    }
}

3.2 二叉树的递归遍历实现

package Binary_Tree_Study;
import java.util.Stack;
import java.util.Queue;
import java.util.LinkedList;
/**
 * Created by Administrator on 2018/5/19.
 */
public class BinaryTree {
    private BinaryTreeNode root;//二叉树根结点

    public BinaryTree() {
        this.root = null;
    }

    /*       建立二叉树：
                 1
               /   \
              2      3
             / \    /
            4   5   6
     */
    public BinaryTreeNode createBinaryTree() {
        root = new BinaryTreeNode(1);
        root.setLeft(new BinaryTreeNode(2));
        root.setRight(new BinaryTreeNode(3));
        root.getLeft().setLeft(new BinaryTreeNode(4));
        root.getLeft().setRight(new BinaryTreeNode(5));
        root.getRight().setLeft(new BinaryTreeNode(6));
        return root;
    }

    //先序遍历:非递归方法
    public void PreOrderIterative(BinaryTreeNode root) {
        BinaryTreeNode temp = root;
        Stack<BinaryTreeNode> s = new Stack<BinaryTreeNode>();
        while (temp != null || !s.isEmpty()) {
            while (temp != null) {  //遇到一个结点，就把它压栈并访问它，然后去遍历它的左子树；
                s.push(temp);
                System.out.print(temp.getData() + " ");
                temp = temp.getLeft();
            }
            if(!s.isEmpty()) {
                temp = s.pop();//当左子树遍历结束后，从栈顶弹出这个结点；
                temp = temp.getRight();//然后按其右指针再去先序遍历该结点的右子树
            }
        }
    }

    //中序遍历:非递归方法
    public void InOrderIterative(BinaryTreeNode root) {
        BinaryTreeNode temp = root;
        Stack<BinaryTreeNode> s = new Stack<BinaryTreeNode>();
        while (temp != null || !s.isEmpty()) {
            while (temp != null) {  //遇到一个结点，就把它压栈，并去遍历它的左子树；
                s.push(temp);
                temp = temp.getLeft();
            }
            if(!s.isEmpty()) {
                temp = s.pop();//当左子树遍历结束后，从栈顶弹出这个结点并访问它；
                System.out.print(temp.getData() + " ");
                temp = temp.getRight();// 然后按其右指针再去中序遍历该结点的右子树
            }
        }
    }

    //后序遍历:非递归方法
    public void PostOrderIterative(BinaryTreeNode root) {
        BinaryTreeNode temp = root;
        BinaryTreeNode pre = null;//标记访问序列中前一个二叉树节点（当前节点的之前访问的节点）
        Stack<BinaryTreeNode> s = new Stack<BinaryTreeNode>();
        while (temp != null || !s.isEmpty()) {
            while (temp != null) {
                s.push(temp);
                temp = temp.getLeft();
            }
            if(!s.isEmpty()) {
                temp = s.peek();
                //如果一个节点右孩子是空，或者右孩子刚被访问过，那么就访问该节点。否则就往右孩子走。
                if(temp.getRight() == null || temp.getRight() == pre) {
                    System.out.print(temp.getData() + " ");
                    s.pop();
                    pre = temp;
                    temp = null;
                }else {
                    temp = temp.getRight();
                }
        }
        }
    }

    //层序遍历
    public void LevelOrder(BinaryTreeNode root) {
        BinaryTreeNode temp;
        Queue<BinaryTreeNode> q = new LinkedList<BinaryTreeNode>();
        if(root == null)
            return;
        q.add(root);
        while (!q.isEmpty()) {
            temp = q.poll();//移除并返问队列头部的元素
            System.out.print(temp.getData() + " ");
            if (temp.getLeft() != null) {
                q.add(temp.getLeft());//左孩子入队
            }
            if (temp.getRight() != null) {
                q.add(temp.getRight());//右孩子入队
            }
        }
    }
}
3.3 测试 
package Binary_Tree_Study;

/**
 * Created by Administrator on 2018/5/19.
 */
public class BinaryTreeTest {
    public static void main(String[] args) {
        BinaryTree tree = new BinaryTree();
        BinaryTreeNode root = tree.createBinaryTree();
        System.out.println("先序遍历为：");
        tree.PreOrderIterative(root);
        System.out.println("\n中序遍历为：");
        tree.InOrderIterative(root);
        System.out.println("\n后序遍历为：");
        tree.PostOrderIterative(root);
        System.out.println("\n层序遍历为：");
        tree.LevelOrder(root);
    }
}

4 参考资料

[1] 二叉树的非递归遍历

[2] 浙大数据结构慕课--中序非递归遍历

[3] 后序遍历---百度百科

[4] Level Order Tree Traversal

[5] 梦回考研——复习二叉树的各种遍历

[6] 数据结构与算法（一）：二叉树的非递归遍历

max_bay
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java实现的二叉树的递归和非递归遍历
05-14
在提供的"二叉树的递归和非递归遍历"压缩包文件中，可能包含了Java源代码，演示了如何实现这两种遍历方式。通过阅读和理解这些代码，你可以更好地掌握二叉树遍历的原理和实践，这对于理解和解决涉及二叉树的算法问题...
二叉树的三种非递归遍历方式（附C、java源码）
x0919的博客
06-29 515
详解二叉树的三种非递归遍历方式（附C、java源码） 前言 二叉树的递归遍历方式很简单，三种递归遍历方式的区别，只是printf放的位置不一样而已，这里就不多讲了。把前序遍历代码贴在这里： //结点 struct Node { int val; struct Node* left, * right; }; //前序遍历 void pre(Node root) { if (root == null) return; printf("%d ",root->val);
二叉树的非递归遍历-java实现
xujiao668的博客
04-25 336
二叉树的先序，中序，和后续遍历，采用非递归的形式 一、先序遍历：（自己做一个栈） 压入根节点，再从栈顶弹出 如果弹出的节点的右孩子不为空，就先把右孩子压栈，左孩子不为空，就把左孩子后压栈 //非递归实现先序遍历 public static void preOrderUnRecur(Node head) { System.out.print("pre-order: "); if (he...
【机器学习】ROC曲线和RP曲线（分类算法）
最新发布
c___ceeee的博客
08-12 1186
1. ROC曲线1. ROC曲线ROC曲线，全称为“接收者操作特性（Receiver Operating Characteristic）”曲线，是一种反映灵敏度和特异度关系的图形工具。在机器学习和统计学中，ROC曲线常用于评估分类模型的性能。其主要特点是展示在不同分类阈值下模型的性能表现。通过调整不同的分类阈值，可以得到不同的假阳性率和真阳性率，这些点在ROC曲线中绘制出来，从而展现出模型的整体性能。AUC值（曲线下面积）则是衡量ROC曲线性能的量化指标。当模型的预测能力更好时，AUC值更高。
Java实现二叉树的三种非递归遍历
CSDNOfWK的博客
11-11 992
Java 实现二叉树的三种非递归遍历1.思路 其实思路就是递归的思路，无非就是加入了栈这个数据结构。 具体来看代码吧，个人觉得还算简洁。 2.实现首先是结点数据结构的设置：/** * @author WK */ public class SearchBinaryTree { //存放的结点标志 public String tag = ""; //是否被便利的标
【Java数据结构】二叉树的前中后序遍历(递归和非递归)
m0_72670269的博客
04-26 1734
*这段代码还有一个问题 我们外层的循环条件是cur!=null 但是我们在cur获取到D的右子节点时 此时cur又为空了 此时循环条件不满足 循环就结束了 但是我们还没有遍历完这棵二叉树 我们还有什么依据来继续循环呢？我们不采用递归的方式 但是要模拟递归的思路。**递归实现的代码都十分相似 **例如这颗树 我们用它举例。前序遍历的遍历方式是。
【Java数据结构】非递归遍历二叉树
Zincy星辰
03-25 1502
目录 1. 定义二叉树结点类TreeNode 2. 前序遍历（非递归） 3. 中序遍历（非递归） 4. 后序遍历（非递归） 1. 定义二叉树结点类TreeNode public class TreeNode { char val; TreeNode left; TreeNode right; public TreeNode(char val) { this.val = val; } } 2. 前序遍历（非递归） public c
用Python实现二叉树、二叉树非递归遍历及绘制的例子
01-20
如果你用C或者C++或者其他高级语言写过二叉树或者阅读过相关方面代码，应该知道二叉树的非递归遍历避不开通过栈或者队列实现。是的，python也一样。但是python自带的list功能很强大，即可以当stack
二叉树的非递归遍历方式（Java）.md
04-24
详细介绍了JAVA中二叉树的非递归遍历方式，三种方式都是采用栈来辅助完成，其中前序遍历采用的是先入右子节点再入左子节点的方法，这样弹出栈时左在前，右在后。中序遍历的话则是要先一直到达最左的子节点，然后才弹...
非递归中序遍历二叉树java代码.docx
10-16
非递归中序遍历是一种在不使用递归方法的情况下遍历二叉树的策略，主要依赖于数据结构栈来实现。在这个Java代码示例中，我们看到的是如何使用栈来执行非递归中序遍历的过程。首先，让我们详细了解二叉树和中序遍历的...
Java实现的二叉树常用操作【前序建树，前中后递归非递归遍历及层序遍历】
08-28
Java实现的二叉树常用操作是指使用Java语言来实现二叉树的各种操作，包括前序建树、前中后递归非递归遍历、层序遍历等。下面我们将详细介绍这些操作的实现方法。 一、前序建树 前序建树是指从一个数组中构建一个...
java语言实现的二叉树的各种操作(包括递归与非递归遍历二叉树,求二叉树的高度，节点总数，叶子节点等)
03-08
java语言实现的二叉树的各种操作(包括递归与非递归遍历二叉树,求二叉树的高度，节点总数，叶子节点等)
二叉树非递归遍历算法 java_java二叉树的非递归遍历
weixin_39915308的博客
02-13 568
二叉树的递归遍历比较简单，这里就不聊了。今天主要聊聊二叉树的非递归遍历，主要借助于“栈”后进先出的特性来保存节点的顺序，先序遍历和中序遍历相对来说比较简单，重点理解后序遍历。1. 先看看节点类型：//二叉树的节点类型private class Node{int data; //节点值Node leftChild; //左孩子Node rightChild; //右孩子public Node(int...
二叉树非递归遍历实现（Java）
weixin_50813307的博客
09-25 1421
二叉树非递归遍历
二叉树的非递归遍历(java)
m0_51262652的博客
02-20 1883
二叉树的遍历 二叉树遍历的路径 : 前中后序二叉树遍历的路劲是一样的! 前序 : 根 -左子树-右子树 在非递归的视角: 在第一次到达这个节点就直接操作这个节点! 中序 : 左子树-根-右子树 在非递归的视角: 在第二次到达这个节点再操作这个节点! 后续 : 左子树-右子树-根 在非递归的视角: 在第三次到达这个节点再操作这个节点! 前序 // 非递归实现二叉树前序遍历 // 具体过程 // 为了先 左 再 右 // 所
Java实现二叉树的递归、非递归遍历
小白
07-23 8796
在计算机科学里，树的遍历是指通过一种方法按照一定的顺序访问一颗树的过程。 对于二叉树，树的遍历通常有四种：先序遍历、中序遍历、后序遍历、广度优先遍历（Breadth Frist Search）（层次遍历）。（前三种亦统称深度优先遍历（Depth First Search））对于多叉树，树的遍历通常有两种：深度优先遍历、广度优先遍历。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍
二叉树的非递归遍历方式（Java）
liyangxueit的博客
04-24 170
二叉树的非递归遍历方式（Java） 前序遍历 思路：就是通过一个栈来实现： 从root开始，root非空先入栈； 进入循环判断，若栈非空，则弹出栈顶元素，打印栈顶元素的值 当弹出的栈顶元素的右子节点非空时，将右子节点压入栈； 当弹出的栈顶元素的左子节点非空时，将左子节点压入栈； 直到栈中无元素。 代码： public static ArrayList<Integer&gt...
二叉树后序遍历非递归实现（java)
行走巨人国
09-29 8916
后序遍历：双栈法，和层次遍历（双队列）很相似，唯一区别在于层次遍历用的是队列，后序遍历用的是栈。 public static void posOrderUnRecur1(Node head){ System.out.print("PosOrder:"); if(head != null){ Stack<Node> s1 = new Stack<Node>();...
Java实现，二叉树递归非递归，前序中序后序遍历（通俗易懂）
热门推荐
youngogo的博客
10-04 1万+
想要弄懂Java的一个知识点，没有比亲自手写一遍更好的方法 仔细研究手写一遍，一定会收获满满，没有你想想中那么难 小编下面以这个二叉树为例，测试代码 以下是完整的四个类代码，大家可先放在自己本地IDE上调试查看，更加清晰 我们需要先将二叉树构建出来，然后进行递归非递归前序中序后序遍历 //二叉树的基本结点 public class Node { Object data...
二叉树非递归遍历：栈实现DFS
"二叉树的非递归遍历C语言实现" 在计算机科学中，二叉树是一种数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。二叉树的遍历是指按照特定顺序访问树中的每一个节点。常见的遍历方法有前序遍历、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值