java递归树形结构（java递归生成树形菜单）

本篇文章给大家谈谈java递归树形结构，以及java递归生成树形菜单对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、如何用递归写一个简单的树形结构示例
• 2、java使用递归实现树形结构
• 3、Java数据结构二叉树深度递归调用算法求内部算法过程详解
• 4、java 怎么把数据库 ID PID（父ID） NAME 三个字段 数据递归处理成树形结构 首ID的PID为0
• 5、如何用Java实现树形结构啊？

如何用递归写一个简单的树形结构示例

模式要点

组成部分

Component : 是组合中的所有对象的统一接口；定义了特定情况下，类应当实现的货缺省的行为；Component 声明一个接口用于访问和管理 Component 的子组件；在递归结构中定义一个接口，用于访问一个父部件，并符合条件的类中实现它，当然这个是可选的。

Leaf：在组合中表示叶节点对象，顾名思义，叶节点没有子节点。

Composite：定义有子部件的那些部件的行为，同时存储子部件，实现 Component 中与子部件有关的接口。

Client：通过Component接口，操纵组合部件的对象。

协作原理

用户使用Component类接口与组合结构中的对象进行交互。 如果接收者是一个叶节点，则直接处理请求。 如果接收者是Composite， 它孝拍通常将请求发送给它的子部件， 在转发请求之前与/或之后可能执行一些辅助操作。

实例分析

在中文中，一宏激句话是由词语组成的，而词语又由字组成；在英文中，句子由单词组成，而单词又由一个个字母组成。每个对象都可定义的它之前的或之后的内容。比如一个中文句子总是以句号结尾，一个英文单词之前通巧绝羡常是有空格的。这种结构可以形成了递归嵌套的结构，句子是父容器，单词是子容器，字母是叶节点。  CharacterComposite 是一个抽象类，定义了所有容器类或叶节点的接口，容器应当实现的功能有：获取子组件、对子组件进行计数、定义组件的格式化输出规则。Sentence(句子) 和 Word (单词)都属于容器，而 Character (字母)则属于叶节点，因为字母中无法再添加子组件了，它是层次结构中的最末端。

/**

* 所有容器的抽象父类

*/public abstract class CharacterComposite {  private ListCharacterComposite children = new ArrayList();  public void add(CharacterComposite character) {

   children.add(character);

 }  public int count() {    return this.children.size();

 }  public void printBefore() {

 }  public void printAfter() {

 }  public void print() {

   printBefore();    for (CharacterComposite item : children) {

     item.print();

   }

   printAfter();

 }

}

EnglishWord 组件前应当输出一个空格，EnglishSentence 组件后应当输出一个“.”，ChineseSentence 组件后应当输出一个“。”等。

/**

* 英文句子

*/public class EnglishSentence extends CharacterComposite {  public EnglishSentence(ListEnglishWord words) {    for (EnglishWord word : words) {

     add(word);

   }

 }  @Override

 public void printAfter() {

   System.out.println(".");

 }

}

/**

* 英文单词

*/public class EnglishWord extends CharacterComposite {  public EnglishWord(ListCharacter characters) {    for (Character c : characters) {

     add(c);

   }

 }  @Override

 public void printBefore() {

   System.out.print(" ");

 }

}

Word 作为 Sentence 的子容器，Character 作为 Word 的子组件，属于叶节点。

/**

* 字母

*/public class Character extends CharacterComposite {  private char c;  public Character(char c) {    this.c = c;

 }  @Override

 public void print() {

   System.out.print(c);

 }

}

Writer 为句子生成器，各个组件及子组件均由它负责填充，最终形成一个完成的结构。

/**

* 语句生成器

*/public class Writer {  public CharacterComposite sentenceByChinese() {

   ListChineseWord words = new ArrayList();

   words.add(new ChineseWord(Arrays.asList(new Character('我'))));

   words.add(new ChineseWord(Arrays.asList(new Character('是'))));

   words.add(new ChineseWord(Arrays.asList(new Character('来'), new Character('自'))));

   words.add(new ChineseWord(Arrays.asList(new Character('北'), new Character('京'))));

   words.add(new ChineseWord(Arrays.asList(new Character('的'))));

   words.add(new ChineseWord(Arrays.asList(new Character('小'), new Character('明'))));    return new ChineseSentence(words);

 }  public CharacterComposite sentenceByEnglish() {

   ListEnglishWord words = new ArrayList();

   words.add(new EnglishWord(Arrays.asList(new Character('I'))));

   words.add(new EnglishWord(Arrays.asList(new Character('a'), new Character('m'))));

   words.add(new EnglishWord(Arrays.asList(new Character('a'))));

   words.add(new EnglishWord(Arrays.asList(new Character('s'), new Character('t'), new Character('u'), new Character('d'), new Character('e'), new Character('n'), new Character('t'))));

   words.add(new EnglishWord(Arrays.asList(new Character('f'), new Character('r'), new Character('o'), new Character('m'))));

   words.add(new EnglishWord(Arrays.asList(new Character('L'), new Character('o'), new Character('n'), new Character('d'), new Character('o'), new Character('n'))));    return new EnglishSentence(words);

 }

}

效果

Composite 模式定义了基本对象和组合对象的基本层次结构，基本对象可以组合形成更复杂的对象，这个对象还可以再次进行组合，依次类推，可以实现无限层的递归嵌套结构，上文中提到的句子-单词-字母结构即是如此。

所有的容器都是这个接口的实现，用户可以一致地使用组合结构和单个对象，用户不需要知道它是否为叶节点或包含子容器的一个组件，从而大大简化了代码结构，定义组合的类时避免了各种复杂的包含着大量判断的方法。

在增加新的组件的时候更简单，无论是新增一种容器或一个叶节点都很方便，无需单独再定义新类并且可以很容易和现有的组件或容器结合工作，客户端无需随新组件的增加而做

java使用递归实现树形结构

insert tb_menu(id, name, 山敬parent) (640000000000,北京市碰唯亮 ,0);

insert tb_menu(id, name, parent) (640100000000,昌平区 ,1);

insert tb_menu(id, name, parent) (640101000000,霍营 ,2);

insert tb_menu(id, name, parent) (640101001000, 回龙观东大街,3);

添加一个节点属性， 根据数据不同代表的地笑宽位不同，0就代表父节点 ，1是0的子节点，2是1的子节点，以此类推。

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

[img]

java 怎么把数据库 ID PID（父ID） NAME 三个字段 数据递归处理成树形结构 首ID的PID为0

如果数据库是oracle，可以用递归的sql实现

如果想用java实现坦培

第一步遍历节让核唯点放入map结构

再次遍历节点，取出当前节点的父节点，parentNode.setchild(courrentNode)

这样第二次遍历完后已经是树形结构了。

从map中取氏春出root节点就行

如何用Java实现树形结构啊？

package tree;

import java.util.LinkedList;

import java.util.List;

/**

* 功能：把一个数组的值存入二叉树中，然后进行3种方式的遍历

*

* 参考资料0:数据结构(C语言版)严蔚敏

*

* 参考资料1：

*

* 参考资料2：

*

* @author ocaicai@yeah.net @date: 2011-5-17

*

*/

public class BinTreeTraverse2 {

private int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

private static ListNode nodeList = null;

/**

* 内部类：节点

*

* @author ocaicai@yeah.net @date: 2011-5-17

*

*/

private static class Node {

Node leftChild;

Node rightChild;

int data;

Node(int newData) {

leftChild = null;

rightChild = null;

data = newData;

}

}

public void createBinTree() {

nodeList = new LinkedListNode();

// 将一个数组的值依次转换为Node节点

for (int nodeIndex = 0; nodeIndex array.length; nodeIndex++) {

nodeList.add(new Node(array[nodeIndex]));

}

// 对前lastParentIndex-1个父节点按照父节点与孩子核卜陪节点的数弊历字关系建立二叉树

for (int parentIndex = 0; parentIndex array.length / 2 - 1; parentIndex++) {

// 左孩子

nodeList.get(parentIndex).leftChild = nodeList

.get(parentIndex * 2 + 1);

// 右孩子

nodeList.get(parentIndex).rightChild = nodeList

.get(parentIndex * 2 + 2);

}

// 最后一个父节点:因为最后一个父节点可能没有右孩子，所以单独拿出来处理

int lastParentIndex = array.length / 2 - 1;

// 左孩子

nodeList.get(lastParentIndex).leftChild = nodeList

.get(lastParentIndex * 2 + 1);

// 右孩子,如果数组的长度为奇数才建立右孩子改蠢

if (array.length % 2 == 1) {

nodeList.get(lastParentIndex).rightChild = nodeList

.get(lastParentIndex * 2 + 2);

}

}

/**

* 先序遍历

*

* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已

*

* @param node

* 遍历的节点

*/

public static void preOrderTraverse(Node node) {

if (node == null)

return;

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

preOrderTraverse(node.leftChild);

preOrderTraverse(node.rightChild);

}

/**

* 中序遍历

*

* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已

*

* @param node

* 遍历的节点

*/

public static void inOrderTraverse(Node node) {

if (node == null)

return;

inOrderTraverse(node.leftChild);

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

inOrderTraverse(node.rightChild);

}

/**

* 后序遍历

*

* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已

*

* @param node

* 遍历的节点

*/

public static void postOrderTraverse(Node node) {

if (node == null)

return;

postOrderTraverse(node.leftChild);

postOrderTraverse(node.rightChild);

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

}

public static void main(String[] args) {

BinTreeTraverse2 binTree = new BinTreeTraverse2();

binTree.createBinTree();

// nodeList中第0个索引处的值即为根节点

Node root = nodeList.get(0);

System.out.println("先序遍历：");

preOrderTraverse(root);

System.out.println();

System.out.println("中序遍历：");

inOrderTraverse(root);

System.out.println();

System.out.println("后序遍历：");

postOrderTraverse(root);

}

}

关于java递归树形结构和java递归生成树形菜单的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。