- ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机
- Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
- 在Ubuntu上搭建网桥的方法
- ubuntu 虚拟机上网方式及相关配置详解
CFSDN坚持开源创造价值,我们致力于搭建一个资源共享平台,让每一个IT人在这里找到属于你的精彩世界.
这篇CFSDN的博客文章Java实现二叉树的建立、计算高度与递归输出操作示例由作者收集整理,如果你对这篇文章有兴趣,记得点赞哟.
本文实例讲述了java实现二叉树的建立、计算高度与递归输出操作。分享给大家供大家参考,具体如下:
1. 建立 递归输出 计算高度 前中后三种非递归输出 。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
public
class
tree_link {
private
int
save =
0
;
private
int
now =
0
;
scanner sc =
new
scanner(system.in);
/*
* 构造函数
*/
tree_link(){
}
/*
* 链表建立
*/
public tree link_build(tree head){
// tree head = new tree();//头节点
system.out.println("继续code:1");
int flag = sc.nextint();
if(flag != 1){
return head;
}else{
system.out.println("\n\n\n输入 节点信息:");
head.setcode(sc.nextint());
system.out.println("\n建立 左 子树code:1 否则:0");
flag = sc.nextint();
if(flag == 1){
now++;
tree ltree = new tree();
head.setltree(ltree);
ltree.setfronttree(head);//设置父母节点
link_build( head.getltree() );
}
system.out.println("\n当前位置:" + head.getcode());
system.out.println("\n建立 右 子树code:1 否则:0");
flag = sc.nextint();
if(flag == 1){
now++;
tree rtree = new tree();
head.setrtree(rtree);
rtree.setfronttree(head);//设置父母节点
link_build( head.getrtree() );
}
if( now > save ){
save = now;
}
now--;
}
return head;
}
/*
* 输出树
*/
public tree output(tree head){
int flag;
if(head.getcode() == -1){
return head;
}else{
system.out.println("\n当前位置:" + head.getcode());
system.out.println(head.getltree() != null);
if(head.getltree() != null){
system.out.println("\n访问 左子树:");
output( head.getltree() );
}
if(head.getrtree() != null){
system.out.println("\n访问 右子树:");
output( head.getrtree() );
}
}
return head;
}
/*
* 获得高度
*/
public int getsave(){
return this.save;
}
/*
* 非递归 前序遍历
*/
public void front_traverse(tree head){
tree star = head;//退出标记
int choose = 1; //左
int flag = 1; //右
system.out.println( "<---前序遍历--->" + head.getcode() );//先访问根
while(true){
if( head.getltree() != null && choose != 0 ){
head = head.getltree();
system.out.println( "<---前序遍历--->" + head.getcode() );//获得信息
flag = 1;
}else if( head.getrtree() != null && flag != 0 ){
head = head.getrtree();
system.out.println( "<---前序遍历--->" + head.getcode() );
choose = 1;
}else if( flag == 0 && choose == 0 && head == star){
break;
}else{
if(head == head.getfronttree().getrtree()){
flag = 0;
choose = 0;
}
if(head == head.getfronttree().getltree()){
choose = 0;
flag = 1;
}
head = head.getfronttree();
system.out.println("获得 父母" + head.getcode());
system.out.println( "\n\n\n" );
}
}
}
/*
* 非递归 中序遍历
*/
public void center_traverse(tree head){
tree star = head;//退出标记
int choose = 1; //左
int flag = 1; //右
while(true){
if( head.getltree() != null && choose != 0 ){
head = head.getltree();
flag = 1;
}else if( head.getrtree() != null && flag != 0 ){
if(head.getltree() == null){//因为左边为空而返回
system.out.println( "<-1--中序遍历--->" + head.getcode());
}
head = head.getrtree();
choose = 1;
}else if( flag == 0 && choose == 0 && head == star){
break;
}else{
int area = 0;//判断哪边回来
flag = 1;
choose = 1;
if(head == head.getfronttree().getrtree()){
area = 1;//右边回来
flag = 0;
choose = 0;
}
if(head == head.getfronttree().getltree()){
area = 2;//左边回来
choose = 0;
flag = 1;
}
if( head.getltree() == null && head.getrtree() == null ){//因为左边为空而返回
system.out.println( "<-2--中序遍历--->" + head.getcode());
}
head = head.getfronttree();
if( area == 2){//因为左边访问完返回
system.out.println( "<-3--中序遍历--->" + head.getcode());
}
system.out.println("获得 父母" + head.getcode());
system.out.println( "\n\n\n" );
}
}
}
/*
* 非递归 后续遍历
*/
public
void
bottom_traverse(tree head){
tree star = head;
//退出标记
int
choose =
1
;
//左
int
flag =
1
;
//右
while
(
true
){
if
( head.getltree() !=
null
&& choose !=
0
){
head = head.getltree();
flag =
1
;
}
else
if
( head.getrtree() !=
null
&& flag !=
0
){
head = head.getrtree();
choose =
1
;
}
else
if
( flag ==
0
&& choose ==
0
&& head == star){
break
;
}
else
{
int
area =
0
;
//判断哪边回来
flag =
1
;
choose =
1
;
if
(head == head.getfronttree().getrtree()){
area =
1
;
//右边回来
flag =
0
;
choose =
0
;
}
if
(head == head.getfronttree().getltree()){
choose =
0
;
flag =
1
;
}
if
(head.getrtree() ==
null
){
//因为右边为空而返回
system.out.println(
"<-1--后序遍历--->"
+ head.getcode());
}
head = head.getfronttree();
if
( area ==
1
){
system.out.println(
"<-2--后序遍历--->"
+ head.getcode());
}
system.out.println(
"获得 父母"
+ head.getcode());
system.out.println(
"\n\n\n"
);
}
}
}
}
|
2. tree 类实现:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
public
class
tree {
private
int
code = -
1
;
private
tree fonttree;
private
tree ltree;
private
tree rtree;
tree(){
this
.code = -
1
;
this
.ltree =
null
;
this
.rtree =
null
;
}
/*
* 树内容查看方法:
*/
public void setcode(int code){//设置编号
this.code = code;
}
public int getcode(){ //获取编号
return this.code;
}
/*
* 设置父母指针:
*/
public void setfronttree(tree front){
this.fonttree = front;
}
public tree getfronttree(){
system.out.println("获得 父母");
return this.fonttree;
}
/*
* 设置左子女:
*/
public void setltree(tree ltree){
this.ltree = ltree;
}
public tree getltree(){
system.out.println("获得左子树");
return this.ltree;
}
/*
* 设置右子女:
*/
public
void
setrtree(tree rtree){
this
.rtree = rtree;
}
public
tree getrtree(){
system.out.println(
"获得右子树"
);
return
this
.rtree;
}
}
|
3. 主函数测试:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public
class
mainactivity {
scanner sc =
new
scanner(system.in);
public
static
void
main(string[] args) {
tree head =
new
tree();
tree_link link_1st =
new
tree_link();
head = link_1st.link_build(head);
system.out.println(
"build succeed !"
);
system.out.println(
"\n二叉树高度-->"
+ link_1st.getsave());
link_1st.output(head);
system.out.println(
"output over !"
);
system.out.println(
"\n\n<----------------前------------------>\n前序访问根:"
);
link_1st.front_traverse(head);
system.out.println(
"\n\n<----------------中------------------>\n中序访问根:"
);
link_1st.center_traverse(head);
system.out.println(
"\n\n<----------------后------------------>\n后序访问根:"
);
link_1st.bottom_traverse(head);
system.out.println(
"\n\n\n\ntext over !\n\n\n"
);
}
}
|
希望本文所述对大家java程序设计有所帮助.
原文链接:https://blog.csdn.net/qq_43377749/article/details/83475907 。
最后此篇关于Java实现二叉树的建立、计算高度与递归输出操作示例的文章就讲到这里了,如果你想了解更多关于Java实现二叉树的建立、计算高度与递归输出操作示例的内容请搜索CFSDN的文章或继续浏览相关文章,希望大家以后支持我的博客! 。
我想在我的 Tree 类中创建一个函数来遍历 n-ary Tree[T] 以取回具有 (level, T) 的元组,以便该 Tree 的用户可以执行类似 tree.traverse.foreach{
给定一个层次格式的数组,它们的直接子级存储在一个连续的数组中,返回一个 n 叉树 给定输入格式: [{'name':'a', 'level': -1}, {'name':'b', 'level
我要求教授给我一份另一个学期的旧作业。它是关于构建一个家谱,然后找到给定的两个节点之间的亲属关系。家谱是关于那美克星人(龙珠z)的,所以每个那美克星人都有一个父亲。 问题是输入是这样的: First
我正在尝试创建一个包含子 vector 的 n 叉树。 这就是我到目前为止所得到的。 在 node.h 文件中我有这个: #include #include using namespa
我正在尝试了解 n 叉树的预序遍历。我一直在阅读,我发现的所有示例都使用左子树和右子树,但是在 n 叉树中,什么是左子树,什么是右子树?有人可以给出一个很好的解释或伪代码吗? 最佳答案 而不是考虑 l
我应该反序列化一个 n 叉树。 这段代码创建了我的树: foodtree.addChildren("Food", { "Plant", "Animal" } ); foodtree.a
我正在尝试创建叉 TreeMap ,但仍然没有成功。这是我的代码: #include #include #include void procStatus(int level) { prin
我有一个二叉树,代表一个解析后的逻辑公式。例如,f = a & b & -c | d 由前缀表示法的列表列表表示,其中第一个元素是运算符(一元或二元),接下来的元素是它们的参数: f = [ |, [
我正在尝试根据给定的输入创建一棵树。那里将有一个根,包括子节点和子子节点。我可以实现树,在其中我可以将子节点添加到特定的主节点(我已经知道根)。但是,我试图弄清楚实现树的推荐方法是什么,我们必须首先从
我在 n 个节点上有一个完整的 19 元树。我标记所有具有以下属性的节点,即它们的所有非根祖先都是最年长或最小的 child (包括根)。我必须为标记节点的数量给出一个渐近界限。 我注意到 第一层有一
如何在不使用递归的情况下遍历 n 叉树? 递归方式: traverse(Node node) { if(node == null) return; for(Node c
我的树/节点类: import java.util.ArrayList; import java.util.List; public class Node { private T data;
关闭。这个问题需要更多focused .它目前不接受答案。 想改善这个问题吗?更新问题,使其仅关注一个问题 editing this post . 4年前关闭。 Improve this questi
我在我的 Java 应用程序中有一个非 UI 使用的所谓的“k-ary”树,我想知道 javax.swing.tree 包是否是完成这项工作的正确工具,即使它与 Swing 打包在一起. 我有一类 W
我正在用 Java 实现 N 叉树;每个节点可以有尽可能多的节点。当我尝试 build 一棵树时,问题就来了。我有一个函数可以递归地创建一个特定高度的树,并根据节点列表分配子节点。当我调用该函数时,根
嗨,我有这段代码来搜索 n 叉树,但它不能正常工作,我不知道这有什么问题当搜索 n4 和 n5 时,它返回 n3怎么了? public FamilyNode findNodeByName(Family
哪个是 C 语言中 N 叉树的简洁实现? 特别是,我想实现一个 n 元树,而不是自平衡的,每个节点中的子节点数量不受限制,其中每个节点都包含一个已经定义的结构,例如: struct task {
#include #include #include typedef struct _Tree { struct _Tree *child; struct _Tree *
我正在编写文件系统层次结构的 N 叉树表示形式,其中每个节点都包含有关它所表示的文件/文件夹的一些信息。 public class TreeNode { private FileSystemE
如何在 R 中为给定数量的分支和深度构建 N 叉树,例如深度为 3 的二叉树? 编辑:将源问题与问答分开。 最佳答案 我想提出解决方案,我用它来构建树数据结构 叶安姆 分支因子。要将数据存储在树中,字
我是一名优秀的程序员,十分优秀!