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数据结构二叉树深度递归调用算法求内部算法过程详解

二叉树

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数据结构二叉树的实例详解（所有基本操作，包括二叉树的高度和节点总数）

#includestdio.h

#includestring.h

#includestdlib.h

#define Max 20 //结点的最大个数

typedef struct node{

char data;

struct node *lchild,*rchild;

}BinTNode; //自定义二叉树的结点类型

typedef BinTNode *BinTree; //定义二叉树的指针

int NodeNum,leaf; //NodeNum为结点数，leaf为叶子数

//基于先序遍历算法创建二叉树

//要求输入先序序列，其中加入虚结点"#"以示空指针的位置

BinTree CreatBinTree(void){

BinTree T;

char ch;

if((ch=getchar())=='#')

return(NULL); //读入#，返回空指针

else{

T=(BinTNode *)malloc(sizeof(BinTNode)); //生成结点

T-data=ch;

T-lchild=CreatBinTree(); //构造左子树

T-rchild=CreatBinTree(); //构造右子树

return(T);

}

}

//先序遍历

void Preorder(BinTree T){

if(T){

printf("%c",T-data); //访问结点

Preorder(T-lchild); //先序遍历左子树

Preorder(T-rchild); //先序遍历右子树

}

}

//中序遍历

void Inorder(BinTree T){

if(T){

Inorder(T-lchild); //中序遍历左子树

printf("%c",T-data); //访问结点

Inorder(T-rchild); //中序遍历右子树

}

}

//后序遍历

void Postorder(BinTree T){

if(T){

Postorder(T-lchild); //后序遍历左子树

Postorder(T-rchild); //后序遍历右子树

printf("%c",T-data); //访问结点

}

}

//采用后序遍历求二叉树的深度、结点数及叶子数的递归算法

int TreeDepth(BinTree T){

int hl,hr,max;

if(T){

hl=TreeDepth(T-lchild); //求左深度

hr=TreeDepth(T-rchild); //求右深度

max=hlhr? hl:hr; //取左右深度的最大值

NodeNum=NodeNum+1; //求结点数

if(hl==0hr==0) leaf=leaf+1; //若左右深度为0，即为叶子。

return(max+1);

}

else return(0);

}

//主函数

void main(){

BinTree root;

int i,depth;

printf("\n");

printf("Creat Bin_Tree； Input preorder:"); //输入完全二叉树的先序序列，

// 用#代表虚结点，如ABD###CE##F##

root=CreatBinTree(); //创建二叉树，返回根结点

do{ //从菜单中选择遍历方式，输入序号。

printf("\t********** select ************\n");

printf("\t1: Preorder Traversal\n");

printf("\t2: Iorder Traversal\n");

printf("\t3: Postorder traversal\n");

printf("\t4: PostTreeDepth,Node number,Leaf number\n");

printf("\t0: Exit\n");

printf("\t*******************************\n");

scanf("%d",i); //输入菜单序号（0-4）

switch (i){

case 1: printf("Print Bin_tree Preorder: ");

Preorder(root); //先序遍历

break;

case 2: printf("Print Bin_Tree Inorder: ");

Inorder(root); //中序遍历

break;

case 3: printf("Print Bin_Tree Postorder: ");

Postorder(root); //后序遍历

break;

case 4: depth=TreeDepth(root); //求树的深度及叶子数

printf("BinTree Depth=%d BinTree Node number=%d",depth,NodeNum);

printf(" BinTree Leaf number=%d",leaf);

break;

case 5: printf("LevePrint Bin_Tree: ");

Levelorder(root); //按层次遍历

break;

default: exit(1);

}

printf("\n");

}while(i!=0);

}

//按层遍历

Levelorder( BinTNode *root){

BinTNode * q[Max]; //定义BinTNode类型的队列 用于存放节点 队列长最大为20个元素

int front=0,rear=0; //初始化队列为空

BinTNode *p; //临时节点指针

if(root!=NULL){ //将根节点进队

rear=(rear+1)%Max;

q[rear]=root;

}

while(front!=rear){

front=(front+1)%Max;

p=q[front]; //删除队首的元素 让两个节点（左右节点）孤立

printf("%c",p-data); //输出队列首元素的值

if(p-left!=null){ //如果存在左孩子节点，则左孩子节点进入队列

rear=(rear+1)%Max;

q[rear]=p-left;

}

if(p-right!=null){ //如果存在右孩子节点，则右孩子节点进入队列

rear=(rear+1)%Max;

q[rear]=p-right;

}

}

}

怎样用Java来体现二叉树（顺便加上注释）

二叉树，和数据库的B树操作流程是一样的，例如：有如下字段

F,C,B,H,K,I；

如果要形成二叉树的话，则，首先取第一个数据作为根节点，所以，现在是 F ，如果字段比根节点小，则保存在左子树，如果比根节点大或者等于根节点则保存在右子树，最后按左---根-----右输出所以数据。

所以，实现的关键就是在于保存的数据上是否存在大小比较功能，而String类中compareTo()有这个能力,节点类要保存两类数据，左节点，右节点

class Node

{

private String data;

private Node left;

private Node right;

public Node (String data){

this.data = data;

}

public void setLeft(Node left) {

this.left = left;

}

public void setRight(Node right){

this.right = right;

}

public String getDate() {

return this.data;

}

public Node getLeft(){

return this.left;

}

public Node getRight(){

return this.right;

}

public void addNode(Node newNode){

if(this.data.compareTo(newNode.data)=0) {

if(this.left == null){

this.left = newNode;

}else {

this.left.addNode(newNode);

}

}else {

if(this.right == null) {

this.right = newNode;

} else {

this.right.addNode(newNode);

}

}

}

public void printNode(){

if(this.left!= null){

this.left.printNode();

}

System.out.println(this.data);

if(this.right != null){

this.right.printNode();

}

}

}

class BinaryTree

{

private Node root = null;

public void add(String data) {

Node newNode = new Node(data);

if(this.root == null) {

this.root = newNode;

}else{

this.root.addNode(newNode);

}

}

public void print() {

this.root.printNode();

}

}

public class Hello

{

public static void main (String args[]) {

BinaryTree link = new BinaryTree();

link.add("F");

link.add("C");

link.add("B");

link.add("H");

link.add("K");

link.add("I");

link.print();

}

}

你一看就英文就知道什么意思了，应该可以理解了

这个二叉树捉摸不透就别琢磨了，开放中一般用不上

}

java的二叉树

好了，代码如下，自己运行下，看下是否符合你的要求：

public class Test

{

static Node root;

static class Node

{

Node left;

Node right;

char data;

Node(char data)

{

this.data = data;

}

}

public static void main(String[] args)

{

String content = "welcomeyou";

for(int i=0;icontent.length();i++)

{

root = insert(root, content.charAt(i));

}

System.out.println("先序遍历结果如下：");

perorder(root);

System.out.println("中序遍历结果如下：");

inorder(root);

System.out.println("后序遍历结果如下：");

postorder(root);

}

public static Node insert(Node node, char data)

{

if(node == null)

node = new Node(data);

else

{

if(node.data data)

node.left = insert(node.left,data);

else

node.right = insert(node.right,data);

}

return node;

}

public static void perorder(Node node)

{

if (node == null)

return;

System.out.println(node.data);

if (node.left != null)

perorder(node.left);

if (node.right != null)

perorder(node.right);

}

public static void inorder(Node node)

{

if (node == null)

return;

if (node.left != null)

inorder(node.left);

System.out.println(node.data);

if (node.right != null)

inorder(node.right);

}

public static void postorder(Node node)

{

if (node == null)

return;

if (node.left != null)

postorder(node.left);

if (node.right != null)

postorder(node.right);

System.out.println(node.data);

}

}

用java怎么构造一个二叉树呢？

java构造二叉树，可以通过链表来构造，如下代码：

public class BinTree {

public final static int MAX=40;

BinTree []elements = new BinTree[MAX];//层次遍历时保存各个节点

int front;//层次遍历时队首

int rear;//层次遍历时队尾

private Object data; //数据元数

private BinTree left,right; //指向左,右孩子结点的链

public BinTree()

{

}

public BinTree(Object data)

{ //构造有值结点

this.data = data;

left = right = null;

}

public BinTree(Object data,BinTree left,BinTree right)

{ //构造有值结点

this.data = data;

this.left = left;

this.right = right;

}

public String toString()

{

return data.toString();

}

//前序遍历二叉树

public static void preOrder(BinTree parent){ 

if(parent == null)

return;

System.out.print(parent.data+" ");

preOrder(parent.left);

preOrder(parent.right);

}

//中序遍历二叉树

public void inOrder(BinTree parent){

if(parent == null)

return;

inOrder(parent.left);

System.out.print(parent.data+" ");

inOrder(parent.right);

}

//后序遍历二叉树

public void postOrder(BinTree parent){

if(parent == null)

return;

postOrder(parent.left);

postOrder(parent.right);

System.out.print(parent.data+" ");

}

// 层次遍历二叉树 

public void LayerOrder(BinTree parent)

{ 

elements[0]=parent;

front=0;rear=1;

while(frontrear)

{

try

{

if(elements[front].data!=null)

{

System.out.print(elements[front].data + " ");

if(elements[front].left!=null)

elements[rear++]=elements[front].left;

if(elements[front].right!=null)

elements[rear++]=elements[front].right;

front++;

}

}catch(Exception e){break;}

}

}

//返回树的叶节点个数

public int leaves()

{

if(this == null)

return 0;

if(left == nullright == null)

return 1;

return (left == null ? 0 : left.leaves())+(right == null ? 0 : right.leaves());

}

//结果返回树的高度

public int height()

{

int heightOfTree;

if(this == null)

return -1;

int leftHeight = (left == null ? 0 : left.height());

int rightHeight = (right == null ? 0 : right.height());

heightOfTree = leftHeightrightHeight?rightHeight:leftHeight;

return 1 + heightOfTree;

}

//如果对象不在树中,结果返回-1;否则结果返回该对象在树中所处的层次,规定根节点为第一层

public int level(Object object)

{

int levelInTree;

if(this == null)

return -1;

if(object == data)

return 1;//规定根节点为第一层

int leftLevel = (left == null?-1:left.level(object));

int rightLevel = (right == null?-1:right.level(object));

if(leftLevel0rightLevel0)

return -1;

levelInTree = leftLevelrightLevel?rightLevel:leftLevel;

return 1+levelInTree;

}

//将树中的每个节点的孩子对换位置

public void reflect()

{

if(this == null)

return;

if(left != null)

left.reflect();

if(right != null)

right.reflect();

BinTree temp = left;

left = right;

right = temp;

}

// 将树中的所有节点移走,并输出移走的节点

public void defoliate()

{

if(this == null)

return;

//若本节点是叶节点，则将其移走

if(left==nullright == null)

{

System.out.print(this + " ");

data = null;

return;

}

//移走左子树若其存在

if(left!=null){

left.defoliate();

left = null;

}

//移走本节点，放在中间表示中跟移走...

String innerNode += this + " ";

data = null;

//移走右子树若其存在

if(right!=null){

right.defoliate();

right = null;

}

}

/**

* @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

BinTree e = new BinTree("E");

BinTree g = new BinTree("G");

BinTree h = new BinTree("H");

BinTree i = new BinTree("I");

BinTree d = new BinTree("D",null,g);

BinTree f = new BinTree("F",h,i);

BinTree b = new BinTree("B",d,e);

BinTree c = new BinTree("C",f,null);

BinTree tree = new BinTree("A",b,c);

System.out.println("前序遍历二叉树结果: ");

tree.preOrder(tree);

System.out.println();

System.out.println("中序遍历二叉树结果: ");

tree.inOrder(tree);

System.out.println();

System.out.println("后序遍历二叉树结果: ");

tree.postOrder(tree);

System.out.println();

System.out.println("层次遍历二叉树结果: ");

tree.LayerOrder(tree);

System.out.println();

System.out.println("F所在的层次: "+tree.level("F"));

System.out.println("这棵二叉树的高度: "+tree.height());

System.out.println("--------------------------------------");

tree.reflect();

System.out.println("交换每个节点的孩子节点后......");

System.out.println("前序遍历二叉树结果: ");

tree.preOrder(tree);

System.out.println();

System.out.println("中序遍历二叉树结果: ");

tree.inOrder(tree);

System.out.println();

System.out.println("后序遍历二叉树结果: ");

tree.postOrder(tree);

System.out.println();

System.out.println("层次遍历二叉树结果: ");

tree.LayerOrder(tree);

System.out.println();

System.out.println("F所在的层次: "+tree.level("F"));

System.out.println("这棵二叉树的高度: "+tree.height());

}

分享文章：java二叉树代码解释 java实现二叉树代码
文章来源：http://pwwzsj.com/article/hpdhdp.html