「java反转二叉树」二叉树反序列化java
本篇文章给大家谈谈java反转二叉树，以及二叉树反序列化java对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、Java二叉树构造问题 要求：从控制台输入一行扩展二叉树的字符串，然后根据这个字符串构造二叉树。THX..
- 2、Java数据结构二叉树深度递归调用算法求内部算法过程详解
- 3、java 构建二叉树
- 4、java 二叉树编程 求救
- 5、课程要求完成一个左右子树交换的Java作业，麻烦大神列一下
- 6、java如何创建一颗二叉树
Java二叉树构造问题 要求：从控制台输入一行扩展二叉树的字符串，然后根据这个字符串构造二叉树。THX..
测试类：
package tree;
import java.util.*;
public class Test {
public static void main(String[] args){
ListTree trees=new ArrayListTree();
int id=1;
Tree tree1=new Tree(0,id++,"张三丰");
Tree tree2=new Tree(tree1.getId(),id++,"武当宋大侠宋远桥");
Tree tree3=new Tree(tree1.getId(),id++,"武当俞二侠俞莲舟");
Tree tree4=new Tree(tree1.getId(),id++,"武当俞三侠俞岱岩");
Tree tree5=new Tree(tree1.getId(),id++,"武当张四侠张松溪");
Tree tree6=new Tree(tree1.getId(),id++,"武当张五侠张翠山");
Tree tree7=new Tree(tree1.getId(),id++,"武当殷六侠殷梨亭");
Tree tree8=new Tree(tree1.getId(),id++,"武当莫七侠莫声谷");
Tree tree9=new Tree(tree6.getId(),id++,"明教张无忌");
Tree tree13=new Tree(tree2.getId(),id++,"叛徒宋青书");
Tree tree10=new Tree(0,id++,"任我行");
Tree tree11=new Tree(tree10.getId(),id++,"令狐冲");
Tree tree12=new Tree(tree10.getId(),id++,"任盈盈");
trees.add(tree1);
trees.add(tree2);
trees.add(tree3);
trees.add(tree4);
trees.add(tree5);
trees.add(tree6);
trees.add(tree7);
trees.add(tree8);
trees.add(tree9);
trees.add(tree10);
trees.add(tree11);
trees.add(tree12);
trees.add(tree13);
for(int i=0;itrees.size();i++){
Tree tree=trees.get(i);
if(tree.getParentId()==0){
tree.showChildTree(trees);
}
}
}
}
树类：
package tree;
import java.util.List;
public class Tree {
private int parentId;
private int id;
private String showStr;
private String Spaces="";
public Tree() {
// TODO Auto-generated constructor stub
}
public Tree(int parentId,int id,String showStr){
this.parentId=parentId;
this.id=id;
this.showStr=showStr;
}
public void showChildTree(ListTree trees){
if(parentId!=0){
trees.get(id-1).setSpaces(trees.get(parentId-1).getSpaces()+" ");
}
System.out.println(trees.get(id-1).getSpaces()+showStr);
for(int i=0;itrees.size();i++){
Tree tree=trees.get(i);
if(tree.getParentId()==id){
tree.showChildTree(trees);
}
}
}
public int getParentId() {
return parentId;
}
public void setParentId(int parentId) {
this.parentId = parentId;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getShowStr() {
return showStr;
}
public void setShowStr(String showStr) {
this.showStr = showStr;
}
public String getSpaces() {
return Spaces;
}
public void setSpaces(String spaces) {
Spaces = spaces;
}
}
控制台效果图：
张三丰
武当宋大侠宋远桥
叛徒宋青书
武当俞二侠俞莲舟
武当俞三侠俞岱岩
武当张四侠张松溪
武当张五侠张翠山
明教张无忌
武当殷六侠殷梨亭
武当莫七侠莫声谷
任我行
令狐冲
任盈盈
Java数据结构二叉树深度递归调用算法求内部算法过程详解
二叉树
1
2 3
4 5 6 7
这个二叉树的深度是3，树的深度是最大结点所在的层，这里是3.
应该计算所有结点层数，选择最大的那个。
根据上面的二叉树代码，递归过程是：
f(1)=f(2)+1 f(3) +1 ? f(2) + 1 : f(3) +1
f(2) 跟f(3)计算类似上面，要计算左右结点，然后取大者
所以计算顺序是f(4.left) = 0, f(4.right) = 0
f(4) = f(4.right) + 1 = 1
然后计算f(5.left) = 0,f(5.right) = 0
f(5) = f(5.right) + 1 =1
f(2) = f(5) + 1 =2
f(1.left) 计算完毕，计算f(1.right) f(3) 跟计算f(2)的过程一样。
得到f(3) = f(7) +1 = 2
f(1) = f(3) + 1 =3
if(depleftdepright){
return depleft+1;
}else{
return depright+1;
}
只有left大于right的时候采取left +1，相等是取right
java 构建二叉树
首先我想问为什么要用LinkedList 来建立二叉树呢? LinkedList 是线性表,
树是树形的, 似乎不太合适。
其实也可以用数组完成，而且效率更高.
关键是我觉得你这个输入本身就是一个二叉树啊，
String input = "ABCDE F G";
节点编号从0到8. 层次遍历的话:
对于节点i.
leftChild = input.charAt(2*i+1); //做子树
rightChild = input.charAt(2*i+2);//右子树
如果你要将带有节点信息的树存到LinkedList里面, 先建立一个节点类:
class Node{
public char cValue;
public Node leftChild;
public Node rightChild;
public Node(v){
this.cValue = v;
}
}
然后遍历input,建立各个节点对象.
LinkedList tree = new LinkedList();
for(int i=0;i input.length;i++)
LinkedList.add(new Node(input.charAt(i)));
然后为各个节点设置左右子树:
for(int i=0;iinput.length;i++){
((Node)tree.get(i)).leftChild = (Node)tree.get(2*i+1);
((Node)tree.get(i)).rightChild = (Node)tree.get(2*i+2);
}
这样LinkedList 就存储了整个二叉树. 而第0个元素就是树根，思路大体是这样吧。
java 二叉树编程 求救
//给的分有点少哦
public class BTNode {
public String data;
public BTNode left;
public BTNode right;
public BTNode(String data, BTNode l, BTNode r) {
this.data = data;
this.left = l;
this.right = r;
}
public BTNode(String data) {
this.data = data;
}
}
public class BTree {
private BTNode root;
public BTree(){
}
public BTree(BTree t){
CopyNodes(t.root, this);
}
private void CopyNodes(BTNode node, BTree tree){
if(node == null){
return;
}
tree.insert(node.data);
CopyNodes(node.left, tree);
CopyNodes(node.right, tree);
}
public void insert(String newData){
root = insert2(newData, root);
}
private BTNode insert2(String s, BTNode n){
if(n == null){
return new BTNode(s);
}
if(s.compareTo(n.data) 0){
n.left = insert2(s, n.left);
}else if(s.compareTo(n.data) 0){
n.right = insert2(s, n.right);
}
return n;
}
public BTNode find(String s){
BTNode node = root;
while(node != null){
if(s.equals(node.data)){
return node;
}
if(s.compareTo(node.data) 0){
node = node.left;
}else{
node = node.right;
}
}
return null;
}
public void printInOrder(){
showNode(root);
}
private void showNode(BTNode node){
if(node == null){
return;
}
showNode(node.left);
System.out.print(node.data + "\t");
showNode(node.right);
}
}
课程要求完成一个左右子树交换的Java作业，麻烦大神列一下
注意：要创建一个SwapTree类才可以复制。
二叉树左右孩子的交换利用了递归和俩数交换的原理。基本思想是将二叉树左右分开俩个分解进行递归！！！考察了递归和俩数交换。是java基础的考察。本文完成与2021/10/12，可以转摘。
/**
* @xiaolei wang
* @date 2021/10/12
* Study Note
*/
public class SwapTree {
public static void main(String args[]) {
Node root = buildTree();
System.out.println("反转之前==============");
inOrderVisit(root);//输出256134
ExchangeLeftRight(root);
System.out.println();//换行
System.out.println("反转之后==============");
inOrderVisit(root);//输出341562
}
class Node {
//定义数据data为父节点，left为左孩子，right为右孩子
int data = 0;
Node left = null;
Node right = null;
}
//定义一个二叉树
public static Node buildTree() {
SwapTree s = new SwapTree();
Node root = s.new Node();
root.data = 1;//父节点
Node temp = s.new Node();
temp.data = 2;
root.left = temp;//父节点左孩子
temp = s.new Node();
temp.data = 3;
root.right = temp;//父节点右孩子
temp = s.new Node();
temp.data = 4;
root.right.right = temp;//父节点右孩子的右孩子
temp = s.new Node();
temp.data = 5;
root.left.right = temp;//左孩子的右孩子
temp = s.new Node();
temp.data = 6;
root.left.right.right = temp;//左孩子的右孩子的右孩子
return root;
}
//
public static void inOrderVisit(Node root) {
if (root == null)
return;
inOrderVisit(root.left);//递归输出左孩子
System.out.print(root.data);//打印父节点
//递归输出右孩子
inOrderVisit(root.right);
}
public static void ExchangeLeftRight(Node node) {
if (node == null)//节点为空 则返回
return;
if (node.left == null node.right == null) {
} else {//交换左右孩子
Node temp = node.left;
node.left = node.right;
node.right = temp;
}
//递归交换孩子
ExchangeLeftRight(node.right);//对右子树进行交换操作
}
}
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)
),
)))
java反转二叉树的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于二叉树反序列化java、java反转二叉树的信息别忘了在本站进行查找喔。