java非递归的后续遍历_Java 二叉树的前、中、后序遍历（递归+非递归）

Java 二叉树的前、中、后序遍历(递归+非递归)

Java 二叉树的前、中、后序遍历(递归+非递归)

代码中的图长这个样子↓↓↓

//非递归里的两部分代码思路过程完全一样，只不过是后者要求返回值为list

import java.util.*;

import java.util.Queue;

class Node{

public char val;

public Node left;//左孩子

public Node right;//右孩子

//为什么把val的类型定义为char类型，输出的就是字母呢？？？定义为int类型输出的就是ASCII码对应的值？？？

//首先因为你蠢，其次，一棵二叉树结点的值本来是字母，你把val定义为整型的，它不输出数字，难道输出字母吗？

//要输出字母肯定要定义为字符类型啊！！！<=我犯的错误=>特别容易忽视的问题！

public Node(char val){

this.val=val;

}

}

public class BinaryTree {

/*private static class Node { //这些参数定义在在类方法外或者内都可以，只是有些需稍加修改

char val;

Node left;

Node right;

public Node(char val) {

this.val = val;

}

}*/

// 1、构造二叉树

public Node buildTree(){

Node A=new Node('A');

Node B=new Node('B');

Node C=new Node('C');

Node D=new Node('D');

Node E=new Node('E');

Node F=new Node('F');

Node G=new Node('G');

Node H=new Node('H');

A.left=B;A.right=C;B.left=D;B.right=E;//这里是构造二叉树的关键

C.left=F;C.right=G;E.right=H;

return A;

}

// 2、(1)递归的前序遍历(根 左 右)

public void preOrderTraversal(Node root){

if(root==null){ //遍历之前肯定要先判断二叉树是否为空

return;

}

System.out.printf(root.val+" ");//先打印根节点，然后递归分别打印左右结点(中序遍历，后序遍历同理)

preOrderTraversal(root.left);

preOrderTraversal(root.right);

}

//对于二叉树的非递归遍历，操作都差不多，会重复，所以得用循环，和栈

// (2)非递归的前序遍历(根 左 右)

//根据前序遍历的思想，首先将结点压入栈，到它该出来的时候再将它出栈

public void preOrderTraversalNor(Node root) {

if (root == null) {

return;

}

Stack stack = new Stack<>();

Node cur = root;//将根结点赋给cur

while (cur != null||!stack.empty()) {//注意循环的条件

while (cur != null) {

stack.push(cur);//将cur入栈

System.out.print(cur.val + " ");//然后打印cur

cur = cur.left;//再让cur=cur.lrft

}

Node top = stack.pop();

cur = top.right;

}

}

//非递归前序遍历(返回值为list)

public List preOrderTraversalNor1(Node root) {

List list=new ArrayList<>();

if (root == null) {

return list;

}

Stack stack = new Stack<>();

Node cur = root;

while (cur != null||!stack.empty()) {

while (cur != null) {

stack.push(cur);//将cur入栈

//System.out.print(cur.val + " ");

list.add(cur.val);//将cur.val放进队列

cur = cur.left;

}

Node top = stack.pop();//将出栈的元素赋给top，然后继续判断top的右子树

cur = top.right;

}

return list;

}

// 3、(1)递归的中序遍历(左 根 右)

public void inOrderTraversal(Node root){

if(root==null){

return;

}

inOrderTraversal(root.left);

System.out.printf(root.val+" ");

inOrderTraversal(root.right);

}

//思路想不起来，代码又看不懂的时候，自个画个二叉树，画个栈，将代码在纸上跑一遍，应该能看懂

// (2)非递归的中序遍历

//根据中序遍历的思想，首先将结点压入栈，到它该出来的时候再将它出栈

public void inOrderTraversalNor(Node root) {

if (root == null) {

return;

}

Stack stack = new Stack<>();

Node cur = root;

while (cur != null||!stack.empty()) {

while (cur != null) {

stack.push(cur);

cur = cur.left;

}

Node top = stack.pop();

System.out.print(top.val + " ");

cur = top.right;

}

}

//非递归中序遍历(返回值为list)

public List inOrderTraversalNor1(Node root) {

List list=new ArrayList<>();

if (root == null) {

return list;

}

Stack stack = new Stack<>();

Node cur = root;

while (cur != null||!stack.empty()) {

while (cur != null) {

stack.push(cur);

cur = cur.left;

}

Node top = stack.pop();

//System.out.print(top.val + " ");

list.add(top.val);

cur = top.right;

}

return list;

}

// 4、(1)递归的后序遍历(左 右 根)

public void postOrderTraversal(Node root){

if(root==null){

return;

}

postOrderTraversal(root.left);

postOrderTraversal(root.right);

System.out.printf(root.val+" ");

}

// (2)非递归后序遍历且耐心！

public void postOrderTraversalNor(Node root){

if (root == null) {

return;

}

Stack stack = new Stack<>();

Node cur = root;

Node prev=null; //定义了一个前驱结点是为了防止重复打印

while (cur != null||!stack.empty()) {

while(cur!=null){

stack.push(cur);//当cur不为空时，就将该结点及该结点的左边入栈，如此循环，直到把最左边的全部入栈

cur=cur.left;

}

cur=stack.peek();//取当前栈顶元素

if(cur.right==null||cur.right==prev){ //判断当前栈顶元素右孩子为空的情况，这样可直接打印当前栈顶元素

System.out.printf(cur.val+" ");

stack.pop();

prev=cur;

cur=null;

}else{//若当前栈顶元素的右孩子不为空，

cur=cur.right;

}

}

}

//非递归后序遍历(返回值为list)

public List postOrderTraversalNor1(Node root){

List list=new ArrayList<>();

if (root == null) {

return list;

}

Stack stack = new Stack<>();

Node cur = root;

Node prev=null;

while (cur != null||!stack.empty()) {

while(cur!=null){

stack.push(cur);

cur=cur.left;

}

cur=stack.peek();//取当前栈顶元素

if(cur.right==null||cur.right==prev){ //判断当前栈顶元素右孩子为空的情况，这样可直接打印当前栈顶元素

//System.out.printf(cur.val+" ");

list.add(cur.val);

stack.pop();//出栈

prev=cur;

cur=null;

}else{//若当前栈顶元素的右孩子不为空，

cur=cur.right;

}

}

return list;

}

public static void main(String[] args) {

BinaryTree binaryTree=new BinaryTree();

Node root=binaryTree.buildTree();

System.out.printf("前序遍历：");

binaryTree.preOrderTraversal(root);

System.out.println();

System.out.printf("非递归前序遍历：");

binaryTree.preOrderTraversalNor(root);

System.out.println();

System.out.println("非递归前序遍历1："+binaryTree.preOrderTraversalNor1(root));

System.out.println();//区分前序遍历和中序遍历

System.out.printf("中序遍历：");

binaryTree.inOrderTraversal(root);

System.out.println();

System.out.printf("非递归中序遍历：");

binaryTree.inOrderTraversalNor(root);

System.out.println();

System.out.println("非递归中序遍历1："+binaryTree.inOrderTraversalNor1(root));

System.out.println();//区分中序遍历和后序遍历

System.out.printf("后序遍历：");

binaryTree.postOrderTraversal(root);

System.out.println();

System.out.printf("非递归后序遍历：");

binaryTree.postOrderTraversalNor(root);

System.out.println();

System.out.println("非递归后序遍历1："+binaryTree.postOrderTraversalNor1(root));

}

}

//问题问着问着，自己就解决了：为什么没有返回值的方法，在最后输出的时候不能将函数写在System.out.println();中？

//是因为，没有返回值的方法体中就有System.out.println();，难道还需要再用一次System.out.println();吗，显然不用！

执行结果：

Java 二叉树的前、中、后序遍历(递归+非递归)相关教程

记一次生产环境Java服务synchronized死锁的处理过程

记一次生产环境Java服务synchronized死锁的处理过程 案例 客户反馈网址响应太慢，有时直接无响应。仿佛卡死一般。 驱动包：mysql-connector-java 5.1.32 过程 看的第一眼，感觉这个问题简单。 响应慢，肯定是系统在进行full gc STW导致系统变慢。 内存泄漏呗

初识RabbitMQ_Java连接RabbitMQ(附源码)

初识RabbitMQ_Java连接RabbitMQ(附源码) 初识RabbitMQ_Java连接RabbitMQ(附源码) 引言： 本文主要分享有关RabbitMQ的相关知识，包括：RabbitMQ的简介、利用main进行演示各种情况下的消息队列、非持久化的简单案例、工作队列、公平的分发消息、实现持久化

java学习笔记6

java学习笔记6 定义方法的格式详解 修饰符 返回值类型 方法名(参数类型 参数名称,....){//代码return 结果;//这里的结果是方法的返回值} 修饰符： public static 固定写法 返回值类型： 表示方法运行的结果的数据类型，方法执行后将结果返回到调用者 参数类型

Java的构造方法不能被重写

Java的构造方法不能被重写 Java的构造方法不能被重写但是可以被重载 首先需要了解一下Java中方法的重写和重载的区别 重载(Overload)是让类以统一的方式处理不同类型数据的一种手段，实质表现就是多个具有不同的参数个数或者类型的同名函数(返回值类型可随

java 最简单的定时器，只需一行

java 最简单的定时器，只需一行 目录 一、项目中使用 二、@Scheduled 定时任务在配置类上添加@EnableScheduling开启对定时任务的支持，在相应的方法上添加@Scheduled声明需要执行的定时任务。 @Scheduled(cron=0 0 21 * * ?) 配置完整格式为： [秒] [分] [小

java基础(二)

java基础(二) java基础 第十章 多线程(基础) 10.1 相关的概念 10.2 两种实现多线程的方式 10.3 线程的生命周期 10.4 Thread的相关API 10.5 关键字：volatile 10.6 关键字：synchronized(同步) 10.7 线程通信 第十一章 常用类 11.1 包装类 11.1.1 包装类

Java基础(四)

Java基础(四) Java基础 第13章 泛型 13.1 泛型的概述 13.2 形式一：泛型类与泛型接口 13.3 形式二：泛型方法 13.4 通配符？ 13.5 Collections工具类 第14章 IO流 14.1 java.io.File类 14.2 IO流的四大抽象基类 14.3 文件IO流 14.4 缓冲IO流 14.5 编码与解码

Java8新特性之Optional类

Java8新特性之Optional类 为什么80%的码农都做不了架构师？ Java8对null有更优雅的处理方式Optional类。 Opthonal类结构 生成Optional对象 Optional.empty OptionalObject empty = Optional.empty(); EMPTY持有某个类型的空值结构,调用empty()返回的即是该实