java非二叉树
⑴ 用java实现树的遍历 不是二叉树
不写代码 只给思路 ：广度优先遍历
1。建一个队列（先进先出），把树的根节点压入队列
2。从队列中弹出一个节点（第一次弹出的就是根节点），把该节点的所有子节点压入队列，如果没有子节点，说明已经到达叶子节点了
3。重复第二步，直到队列为空，说明所有的叶子节点都已经经过了队列，也就完成了遍历
⑵ java中的二叉树是什么意思
二叉树的相关操作，包括创建，中序、先序、后序（递归和非递归），其中重点的是java在先序创建二叉树和后序非递归遍历的的实现。
⑶ 关于java中的二叉树
感觉你的问题好奇怪
你是怎么知道node是指向谁的？
既然你知道node指向谁了，那它就可以访问它里面的成员变量，leftChild不是它的成员变量吗？它只要知道它的leftChild存在就行了，leftChild指向谁它不管
////////////////////////////
你的意思是再往下一层？
⑷ java中 遍历树的方法一个非二叉树
可以，查找所有的节点看看没有父节点就行了。存在父节点的就不是根，而不存在父节点就是根节点。
⑸ 用JAVA语言实现二叉树的层次遍历的非递归算法及查找算法。
先序非递归算法
【思路】
假设：T是要遍历树的根指针，若T != NULL
对于非递归算法，引入栈模拟递归工作栈，初始时栈为空。
问题：如何用栈来保存信息，使得在先序遍历过左子树后，能利用栈顶信息获取T的右子树的根指针？
方法1：访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。
方法2：访问T->data后，将T->rchild入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T->rchild，出栈，遍历以该指针为根的子树。
【算法1】
void PreOrder(BiTree T, Status ( *Visit ) (ElemType e))
{ // 基于方法一
InitStack(S);
while ( T!=NULL || !StackEmpty(S)){
while ( T != NULL ){
Visit(T->data) ;
Push(S,T);
T = T->lchild;
}
if( !StackEmpty(S) ){
Pop(S,T);
T = T->rchild;
}
}
}
【算法2】
void PreOrder(BiTree T, Status ( *Visit ) (ElemType e))
{ // 基于方法二
InitStack(S);
while ( T!=NULL || !StackEmpty(S) ){
while ( T != NULL ){
Visit(T->data);
Push(S, T->rchild);
T = T->lchild;
}
if ( !StackEmpty(S) ){
Pop(S,T);
}
}
}
进一步考虑：对于处理流程中的循环体的直到型、当型+直到型的实现。
中序非递归算法
【思路】
T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。
问题：如何用栈来保存信息，使得在中序遍历过左子树后，能利用栈顶信息获取T指针？
方法：先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。
【算法】
void InOrder(BiTree T, Status ( *Visit ) (ElemType e))
{
InitStack(S);
while ( T!=NULL || !StackEmpty(S) ){
while ( T != NULL ){
Push(S,T);
T = T->lchild;
}
if( !StackEmpty(S) ){
Pop(S, T);
Visit(T->data);
T = T->rchild;
}
}
}
进一步考虑：对于处理流程中的循环体的直到型、当型+直到型的实现。
后序非递归算法
【思路】
T是要遍历树的根指针，后序遍历要求在遍历完左右子树后，再访问根。需要判断根结点的左右子树是否均遍历过。
可采用标记法，结点入栈时，配一个标志tag一同入栈(0：遍历左子树前的现场保护，1：遍历右子树前的现场保护)。
首先将T和tag(为0)入栈，遍历左子树；返回后，修改栈顶tag为1，遍历右子树；最后访问根结点。 [Page]
typedef struct stackElement{
Bitree data;
char tag;
}stackElemType;
【算法】
void PostOrder(BiTree T, Status ( *Visit ) (ElemType e))
{
InitStack(S);
while ( T!=NULL || !StackEmpty(S) ){
while ( T != NULL ){
Push(S,T,0);
T = T->lchild;
}
while ( !StackEmpty(S) && GetTopTag(S)==1){
Pop(S, T);
Visit(T->data);
}
if ( !StackEmpty(S) ){
SetTopTag(S, 1); // 设置栈顶标记
T = GetTopPointer(S); // 取栈顶保存的指针
T = T->rchild;
}else break;
}
}
⑹ java树（不是二叉树） 求最小值
既然涉及到二叉树了，递归就肯定存在了
private Baumknoten deleteMaxValue() {
Baumknoten newRoot; //一个节点
if (this.rightTree == null) { //右子节点 == null
newRoot = this.leftTree; //赋值
} else {
this.rightTree = this.rightTree.deleteMaxValue(); //本节点 = 本节点的右子节点的这个方法（也就是你贴出来的方法）返回的节点。
newRoot = this; //节点赋值
}
return newRoot; //返回节点
}
这就是一个递归，或许树的定义是左子节点比父节点小，右子节点比父节点大，
但有些出路，不能肯定。
递归的意思就是在方法内部调用自己，满足一定条件后跳出，可以理解为循环，
但有些循环是不能实现某些递归能实现的功能的。
我给你讲解下这个方法的意思吧：
其实这个方法的需求是找出二叉树中最大的值，并返回。
假设树的定义是左子节点比父节点小，右子节点比父节点大的常规树：
进入方法，定义一个节点，然后判断当前节点的右节点是不是空，如果是空就证
明当前节点是最大值了，返回当前节点就行了（但他返回的是当前节点的左子节
点，诧异！），如果不是空就调用当前节点的右子节点的deleteMaxValue方法
（也就是你贴出来的方法，是自己，这就构成了递归），并把右子节点的
deleteMaxValue方法的返回值返回到父节点的方法里，父节点的方法接收返回值
并返回给调用者，进入右子节点的deleteMaxValue方法后，继续上面的操作，直
到满足了条件跳出为止，条件就是if (this.rightTree == null)。
典型的递归。
请参考
⑺ 用java编写一个非递归的二叉树的遍历，急要！！！
import java.util.LinkedList;
import java.util.Stack;
public class MainTest {
public static void scanTree1(Tree root) { //横向遍历
LinkedList<Tree> queue = new LinkedList<Tree>();
queue.add(root);
while (!queue.isEmpty()) {
Tree node = queue.poll();
System.out.println(node.getData());
Tree left = node.getLeft();
Tree right = node.getRight();
if (left != null) {
queue.add(left);
}
if (right != null) {
queue.add(right);
}
}
}
public static void scanTree2(Tree root) { //纵向前序
Tree node = root;
Stack<Boolean> stack = new Stack<Boolean>();
boolean leftFlg = false;
while (true) {
System.out.println(node.getData());
if (node.getLeft() != null && leftFlg) {
node = node.getLeft();
stack.add(true);
leftFlg = true;
} else if (node.getRight() != null) {
node = node.getRight();
stack.add(false);
leftFlg = true;
} else if (stack.isEmpty()) {
break;
} else if (stack.pop()) {
node = node.getParent();
leftFlg = false;
}
}
}
public static void scanTree3(Tree root) {//纵向中序
Tree node = root;
Stack<Boolean> stack = new Stack<Boolean>();
boolean leftFlg = false;
while (true) {
if (node.getLeft() != null && leftFlg) {
node = node.getLeft();
stack.add(true);
leftFlg = true;
} else if (node.getRight() != null) {
System.out.println(node.getData());
node = node.getRight();
stack.add(false);
leftFlg = true;
} else if (stack.isEmpty()) {
break;
} else if (stack.pop()) {
node = node.getParent();
leftFlg = false;
}
}
}
public static void scanTree4(Tree root) {//纵向后序
Tree node = root;
Stack<Boolean> stack = new Stack<Boolean>();
boolean leftFlg = false;
while (true) {
if (node.getLeft() != null && leftFlg) {
node = node.getLeft();
stack.add(true);
leftFlg = true;
} else if (node.getRight() != null) {
node = node.getRight();
stack.add(false);
leftFlg = true;
} else if (stack.isEmpty()) {
break;
} else if (stack.pop()) {
System.out.println(node.getData());
node = node.getParent();
leftFlg = false;
}
}
}
public static void main(String[] args) {
Tree root = new Tree();
// TODO
scanTree1(root);
scanTree2(root);
scanTree3(root);
scanTree4(root);
}
}
class Tree {
private Tree left;
private Tree right;
private Tree parent;
private Object data;
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public Tree getLeft() {
return left;
}
public void setLeft(Tree left) {
this.left = left;
}
public Tree getRight() {
return right;
}
public void setRight(Tree right) {
this.right = right;
}
public Tree getParent() {
return parent;
}
public void setParent(Tree parent) {
this.parent = parent;
}
}
⑻ java如何创建一颗二叉树
计算机科学中，二叉树是每个结点最多有两个子树的有序树。通常子树的根被称作“左子树”（left
subtree）和“右子树”（right
subtree）。二叉树常被用作二叉查找树和二叉堆或是二叉排序树。
二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2的
i
-1次方个结点；深度为k的二叉树至多有2^(k)
-1个结点；对任何一棵二叉树T，如果其终端结点数(即叶子结点数)为n0，度为2的结点数为n2，则n0
=
n2
+
1。
树是由一个或多个结点组成的有限集合，其中：
⒈必有一个特定的称为根(ROOT)的结点；
二叉树
⒉剩下的结点被分成n>=0个互不相交的集合T1、T2、......Tn，而且，
这些集合的每一个又都是树。树T1、T2、......Tn被称作根的子树(Subtree)。
树的递归定义如下：（1）至少有一个结点（称为根）（2）其它是互不相交的子树
1.树的度——也即是宽度，简单地说，就是结点的分支数。以组成该树各结点中最大的度作为该树的度，如上图的树，其度为2;树中度为零的结点称为叶结点或终端结点。树中度不为零的结点称为分枝结点或非终端结点。除根结点外的分枝结点统称为内部结点。
2.树的深度——组成该树各结点的最大层次。
3.森林——指若干棵互不相交的树的集合，如上图，去掉根结点A，其原来的二棵子树T1、T2、T3的集合{T1,T2,T3}就为森林；
4.有序树——指树中同层结点从左到右有次序排列，它们之间的次序不能互换，这样的树称为有序树，否则称为无序树。
树的表示
树的表示方法有许多，常用的方法是用括号：先将根结点放入一对圆括号中，然后把它的子树由左至右的顺序放入括号中，而对子树也采用同样的方法处理；同层子树与它的根结点用圆括号括起来，同层子树之间用逗号隔开，最后用闭括号括起来。如右图可写成如下形式：
二叉树
(a(
b(d,e),
c(
f(
,g(h,i)
),
)))