Java数据结构——二叉树的递归与非递归遍历(DFS)

二叉树的遍历分为递归遍历和非递归遍历

一、递归实现前、中、后序遍历
Node.java:

public class Node {
private Object data;
Node richild;
Node lechild;

public Object getData() {
return data;
}

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

public Node getRichild() {
return richild;
}

public void setRichild(Node richild) {
this.richild = richild;
}

public Node getLechild() {
return lechild;
}

public void setLechild(Node lechild) {
this.lechild = lechild;
}

public Node(Object data, Node lechild, Node richild) {
super();
this.data = data;
this.richild = richild;
this.lechild = lechild;
}

public Node() {
super();
}

}

递归遍历:

public class BTree {

private static Node root;
//构造树
public static void init() {
Node node1 = new Node("A", null, null);
Node node2 = new Node("B", node1, null);
Node node3 = new Node("C", null, null);
Node node4 = new Node("D", node2, node3);
Node node5 = new Node("E", null, null);
Node node6 = new Node("F", null, node5);
Node node7 = new Node("G", node4, node6);
root = node7;
}
//访问节点
public static void visited(Node n) {
System.out.print(n.getData() + " ");
}
//前序遍历
public static void preOrder(Node n) {
if (n != null) {
visited(n);
preOrder(n.getLechild());
preOrder(n.getRichild());
}
}
//中序遍历
public static void inOrder(Node n) {
if (n != null) {
inOrder(n.getLechild());
visited(n);
inOrder(n.getRichild());
}
}
//后序遍历
public static void postOrder(Node n) {
if (n != null) {
postOrder(n.getLechild());
postOrder(n.getRichild());
visited(n);
}
}

public static void main(String[] args) {
init();
System.out.print("递归前序:");
preOrder(root);
System.out.println();
System.out.print("递归中序:");
inOrder(root);
System.out.println();
System.out.print("递归后序:");
postOrder(root);
System.out.println();
}

}

二、非递归实现前、中、后序遍历

import java.util.Stack;
public class BTree2 {
private static Node root;
//构造树
public static void init() {
Node node1 = new Node("A", null, null);
Node node2 = new Node("B", node1, null);
Node node3 = new Node("C", null, null);
Node node4 = new Node("D", node2, node3);
Node node5 = new Node("E", null, null);
Node node6 = new Node("F", null, node5);
Node node7 = new Node("G", node4, node6);
root = node7;
}
//前序遍历
public static void preOrder(Node n) {
System.out.print("非递归前序:");
Stack<Node> stack = new Stack<>();
int index = 0;
while (n != null || index > 0) {
while (n != null) {
System.out.print(n.getData() + " ");
stack.push(n);
index++;
n = n.getLechild();
}
n = stack.pop();
index--;
n = n.getRichild();
}
}
//中序遍历
public static void inOrder(Node n) {
System.out.print("非递归中序:");
Stack<Node> stack = new Stack<>();
int index = 0;
while (n != null || index > 0) {
while (n != null) {
stack.push(n);
index++;
n = n.getLechild();
}
n = stack.pop();
System.out.print(n.getData() + " ");
index--;
n = n.getRichild();
}
}
//后序遍历
public static void postOrder(Node n) {
System.out.print("非递归后序:");
Stack<Node> stack = new Stack<>();
int index = 0;
Node lastVisited = null;
while (n != null || index > 0) {
while (n != null) {
stack.push(n);
index++;
n = n.getLechild();
}
n = stack.peek();
if (n.getRichild() == null || n.getRichild() == lastVisited) {
System.out.print(n.getData() + " ");
lastVisited = n;
index--;
stack.pop();
n = null;
} else {
n = n.getRichild();
}
}
}

public static void main(String[] args) {
init();
preOrder(root);
System.out.println();
inOrder(root);
System.out.println();
postOrder(root);
System.out.println();
}
}

 

三、查找最大值

// 查找最大值
public static Node maxNode() {
Node node = root;
Node maxNode = node;
while (node != null) {
maxNode = node;
node = node.getRichild();
}
return maxNode;
}

  

四、查找最小值

// 查找最小值
public static Node minNode() {
Node node = root;
Node minNode = node;
while (node != null) {
minNode = node;
node = node.getLechild();
}
return minNode;
}

  

五、插入节点

// 插入节点
public static boolean insert(Object data, Node parent) {
Node node = new Node(data, null, null);
if (root == null || parent == null) {
root = node;
return true;
} else if (parent.getLechild() != null && parent.getRichild() != null) {
return false;
} else {
if (parent.getLechild() != null) {
parent.setRichild(node);
} else {
parent.setLechild(node);
}
return true;
}
}

  

六、查找节点

// 查找节点
public static void find(Node n, Object data) {
if (n != null) {
if (n.getData() == data) {
System.out.println(n);
return;
} else {
find(n.getLechild(), data);
find(n.getRichild(), data);
}
}
}

原文地址:https://www.cnblogs.com/ericz2j/p/10679324.html

时间: 2024-10-15 06:26:32

Java数据结构——二叉树的递归与非递归遍历(DFS)的相关文章

数据结构二叉树的递归与非递归遍历之 实现可编译(1)java

前一段时间,学习数据结构的各种算法,概念不难理解,只是被C++的指针给弄的犯糊涂,于是用java,web,javascript,分别去实现数据结构的各种算法. 二叉树的遍历,本分享只是以二叉树中的先序遍历为例进行说明,中序遍历和后序遍历,以此类推! 二叉树递归与非递归遍历的区别,虽然递归遍历,跟容易读懂,代码量少,运算快,但是却容易出现溢出的问题,所以所以非递归遍历,在处理千万级的运算量时会先的很有用处. 二叉树的先序遍历:先访问根节点,再访问先后访问左右节点.如图: 二叉树的递归遍历之java

Java数据结构系列之——树(4):二叉树的中序遍历的递归与非递归实现

package tree.binarytree; import java.util.Stack; /** * 二叉树的中序遍历:递归与非递归实现 * * @author wl * */ public class BiTreeInOrder { // 中序遍历的递归实现 public static void biTreeInOrderByRecursion(BiTreeNode root) { if (root == null) { return; } biTreeInOrderByRecursi

Java数据结构系列之——树(5):二叉树的后序遍历的递归与非递归实现

package tree.binarytree; import java.util.Stack; /** * 二叉树后序遍历的递归与非递归实现 * * @author wl * */ public class BitreePostOrder { // 后序遍历的递归实现 public static void biTreePostOrderByRecursion(BiTreeNode root) { if (root == null) { return; } biTreePostOrderByRe

JAVA递归、非递归遍历二叉树(转)

原文链接: JAVA递归.非递归遍历二叉树 import java.util.Stack; import java.util.HashMap; public class BinTree { private char date; private BinTree lchild; private BinTree rchild; public BinTree(char c) { date = c; } // 先序遍历递归 public static void preOrder(BinTree t) {

二叉树三种遍历递归及非递归实现(Java)

import java.util.Stack; //二叉树三种遍历递归及非递归实现(Java) public class Traverse { /******************定义二叉树**************************/ private final int MAX_SIZE = 10; //链式存储 public static class BinaryTreeNode { int mValue; BinaryTreeNode mLeft; BinaryTreeNode

二叉树三种遍历(递归以及非递归实现)

package com.shiyeqiang.tree; import java.util.Stack; public class BiTree { public static void main(String[] args) { // 首先构造叶子节点 BiTree leafA1 = new BiTree(4); BiTree leafA2 = new BiTree(5); BiTree leafB1 = new BiTree(6); BiTree leafB2 = new BiTree(7)

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

本文部分来源于CSDN兰亭风雨大牛的原创.链接为http://blog.csdn.net/ns_code/article/details/12977901 二叉树是一种非常重要的数据结构,很多其他数据机构都是基于二叉树的基础演变过来的.二叉树有前.中.后三种遍历方式,因为树的本身就是用递归定义的,因此采用递归的方法实现三种遍历,不仅代码简洁且容易理解,但其开销也比较大,而若采用非递归方法实现三种遍历,则要用栈来模拟实现(递归也是用栈实现的).下面先简要介绍三种遍历方式的递归实现,再详细介绍三种遍

C实现二叉树(模块化集成,遍历的递归与非递归实现)

C实现二叉树模块化集成 实验源码介绍(源代码的总体介绍):header.h : 头文件链栈,循环队列,二叉树的结构声明和相关函数的声明.LinkStack.c : 链栈的相关操作函数定义.Queue.c : 循环队列的相关操作函数定义.BinTree.c : 二叉树的相关操作的函数定义,层序序列生成二叉树,二叉树的前序序列.中序序列.后序序列的递归和非递归实现,求叶子结点的递归与非递归实现,求树高.我目前还是新手且第一次写类似的博客,文章中难免会有错误!如发现错误,望各路大神能够指出!详见源代码

二叉树的广度优先遍历、深度优先遍历的递归和非递归实现方式

二叉树的遍历方式: 1.深度优先:递归,非递归实现方式 1)先序遍历:先访问根节点,再依次访问左子树和右子树 2)中序遍历:先访问左子树,再访问根节点吗,最后访问右子树 3)后序遍历:先访问左子树,再访问右子树,最后访问根节点 2.广度优先     按照树的深度,一层一层的访问树的节点 1 package Solution; 2 3 import java.util.LinkedList; 4 import java.util.Queue; 5 import java.util.Stack; 6

每天刷个算法题20160521:二叉树高度(递归与非递归)

版权所有.所有权利保留. 欢迎转载,转载时请注明出处: http://blog.csdn.net/xiaofei_it/article/details/51502727 为了防止思维僵化,每天刷个算法题.已经刷了几天了,现在发点代码. 我已经建了一个开源项目,每天的题目都在里面: https://github.com/Xiaofei-it/Algorithms 绝大部分算法都是我自己写的,没有参考网上通用代码.读者可能会觉得有的代码晦涩难懂,因为那是我自己的理解. 最近几天都是在写一些原来的东西