「java集合树状」java集合结构图
今天给各位分享java集合树状的知识，其中也会对java集合结构图进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、用Java实现一个树形结构，并对其进行遍历
- 2、(java)有一个100000个节点的树形结构，求所有节点数大于L=3小于R=5的路径的组合，有什么效率高的方法吗？
- 3、如何用Java实现树形结构啊？
- 4、java怎么设置树状列表使得其默认为展开
- 5、java使用递归实现树形结构
- 6、java中的集合分类
用Java实现一个树形结构，并对其进行遍历
import java.util.Iterator;
import java.util.Random;
import java.util.TreeSet;
public class Demo{
public static void main(String[] args) throws Exception {
TreeSetInteger ts = new TreeSetInteger();
for(int i = 0; i 10; i++){
ts.add(new Random().nextInt(999));
}
for(IteratorInteger it = ts.iterator(); it.hasNext();){
System.out.println(it.next());
}
}
}
//上面是利用TreeSet进行简单的二叉树实现，另有遍历，当然遍历是自然顺序。
//如有需要请自行修改吧。
(java)有一个100000个节点的树形结构，求所有节点数大于L=3小于R=5的路径的组合，有什么效率高的方法吗？
如果采用非递归算法实现二叉树的前序遍历，需要借助于栈结构。其步骤如下：
如果根节点rt为空，则返回；否则，首先将根节点压入栈中，然后迭代执行以下步骤：
1. 弹出栈顶存放的节点n，访问该节点；
2. 依次将n的右子节点和左子节点压入栈中；
3. 如果栈不为空，则返回步骤1继续执行，否则结束迭代。
其中步骤1为节点访问操作；步骤2中先将右子节点压入栈中然后再将左子节点压入，这是因为在栈的弹出操作服从先入后出的准则，根节点访问结束后需要先访问的是左子节点，所以左子节点在右子节点之后压栈；步骤3是遍历过程终止的条件。
根据上述迭代步骤，图中二叉树的遍历步骤可以分解为如下步骤，对应如图所示。
1． 将n14压栈；
2． 弹出栈顶节点，此时为n14，访问节点n14；
3． 将n14的右子节点n13和左子节点n8依次压入栈中；
4． 弹出栈顶节点，此时为n8，访问节点n8；
5． 将n8的右子节点n7和左子节点n4依次压入栈中；
6． 弹出栈顶节点，此时为n4，访问节点n4；
7． 将n4的右子节点n3和左子节点n2依次压入栈中；
8． 弹出栈顶节点，此时为n2，访问节点n2；
9． n2的右子节点为空，则将n2的左子节点n1压入栈中；
10．弹出栈顶节点，此时为n1，访问节点n1；
11．n1的左子节点为空，则将n1的右子节点n0压入栈中；
12．弹出栈顶节点，此时为n0，访问节点n0；
13．n0为叶节点，则无子节点压栈；
14．弹出栈顶节点，此时为n3，访问节点n3；
15．n3为叶节点，则无子节点压栈；
16．弹出栈顶节点，此时为n7，访问节点n7；
17．将n7的右子节点n6和左子节点n5依次压栈；
18．弹出栈顶节点，此时为n5，访问节点n5；
19．n5为叶节点，无子节点压栈；
20．弹出栈顶节点，此时为n6，访问节点n6；
21．n6为叶节点，无子节点压栈；
22．弹出栈顶节点，此时为n13，访问节点n13；
23．将n13的右子节点n11和左子节点n12依次压栈；
24．弹出栈顶节点，此时为n12，访问节点n12；
25．n12为叶节点，无子节点压栈；
26．弹出栈顶节点，此时为n11，访问节点n11；
27．将n11的右子节点n10和左子节点n9依次压入栈中；
28．弹出栈顶节点，此时为n9，访问节点n9；
29．n9为叶节点，则无子节点压栈；
30．弹出栈顶节点，此时为n10，访问节点n10；
31．n10为叶节点，则无子节点压栈；
32．栈空，遍历过程结束。
图 二叉树前序遍历算法栈结构动态过程
迭代过称中利用了栈结构，图示的栈结构中栈的大小是固定的，事实上在实现时预先设定好栈的大小并不容易，所以在具体实现时，采用第XX章中讨论的链式栈，动态调整栈的大小。
中序遍历
第二种遍历算法称为中序遍历算法。与前序遍历算法相比，中序遍历算法首先访问节点的左子树，然后访问节点自身，最后访问节点的右子树。可见，节点自身是在访问左右子树中间访问的，顾称之为中序。图中的二叉树的中序遍历结果为：
如何用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后台实现），所以java只负责发送这些html代码，而页面控制就要交给前端的js来控制
所以要设置列表默认展开，只要把该区域的div设置为非隐藏即可
也可以使用js的一些类库来实现树状列表
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中的集合分类
JAVA集合框架特征介绍(详细的去看看动力节点的java基础大全301集就知道了）
数据结构是以某种形式将数据组织在一起的集合，它不仅存储数据，还支持访问和处理数据的操作。Java提供了几个能有效地组织和操作数据的数据结构，这些数据结构通常称为Java集合框架。在平常的学习开发中，灵活熟练地使用这些集合框架，可以很明显地提高我们的开发效率，当然仅仅会用还是不够的，理解其中的设计思想与原理才能更好地提高我们的开发水平。下面是自己对Java集合框架方面的学习总结。
一、概述
二、Collection接口 1.List 2.Set 3.Queue
三、Map接口 1.HashMap实现原理 2.其它Map实现类
四、其它集合类
五、总结
一、概述
在Java 2之前，Java是没有完整的集合框架的。它只有一些简单的可以自扩展的容器类，比如Vector，Stack，Hashtable等。这些容器类在使用的过程中由于效率问题饱受诟病，因此在Java 2中，Java设计者们进行了大刀阔斧的整改，重新设计，于是就有了现在的集合框架。需要注意的是，之前的那些容器类库并没有被弃用而是进行了保留，主要是为了向下兼容的目的，但我们在平时使用中还是应该尽量少用。
Java集合框架
从上面的集合框架图可以看到，Java集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection接口又有3种子类型，List、Set和Queue，再下面是一些抽象类，最后是具体实现类，常用的有ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap等等。
二、Collection接口
Collection接口是处理对象集合的根接口，其中定义了很多对元素进行操作的方法，AbstractCollection是提供Collection部分实现的抽象类。下图展示了Collection接口中的全部方法。
Collection接口结构
其中，有几个比较常用的方法，比如方法add()添加一个元素到集合中，addAll()将指定集合中的所有元素添加到集合中，contains()方法检测集合中是否包含指定的元素，toArray()方法返回一个表示集合的数组。Collection接口有三个子接口，下面详细介绍。
1.List
List接口扩展自Collection，它可以定义一个允许重复的有序集合，从List接口中的方法来看，List接口主要是增加了面向位置的操作，允许在指定位置上操作元素，同时增加了一个能够双向遍历线性表的新列表迭代器ListIterator。AbstractList类提供了List接口的部分实现，AbstractSequentialList扩展自AbstractList，主要是提供对链表的支持。下面介绍List接口的两个重要的具体实现类，也是我们可能最常用的类，ArrayList和LinkedList。
ArrayList
通过阅读ArrayList的源码，我们可以很清楚地看到里面的逻辑，它是用数组存储元素的，这个数组可以动态创建，如果元素个数超过了数组的容量，那么就创建一个更大的新数组，并将当前数组中的所有元素都复制到新数组中。假设第一次是集合没有任何元素，下面以插入一个元素为例看看源码的实现。
1、方法add(E e)向集合中添加指定元素。 public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e; return true;
}2、此方法主要是确定将要创建的数组大小。 private void ensureCapacityInternal(int minCapacity) { if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
} private void ensureExplicitCapacity(int minCapacity) {
modCount++; if (minCapacity - elementData.length 0)
grow(minCapacity);
}3、最后是创建数组，可以明显的看到先是确定了添加元素后的大小之后将元素复制到新数组中。 private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; int newCapacity = oldCapacity + (oldCapacity 1); if (newCapacity - minCapacity 0)
newCapacity = minCapacity; if (newCapacity - MAX_ARRAY_SIZE 0)
newCapacity = hugeCapacity(minCapacity); // minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
LinkedList
同样，我们打开LinkedList的源文件，不难看到LinkedList是在一个链表中存储元素。
在学习数据结构的时候，我们知道链表和数组的最大区别在于它们对元素的存储方式的不同导致它们在对数据进行不同操作时的效率不同，同样，ArrayList与LinkedList也是如此，实际使用中我们需要根据特定的需求选用合适的类，如果除了在末尾外不能在其他位置插入或者删除元素，那么ArrayList效率更高，如果需要经常插入或者删除元素，就选择LinkedList。
2.Set
Set接口扩展自Collection，它与List的不同之处在于，规定Set的实例不包含重复的元素。在一个规则集内，一定不存在两个相等的元素。AbstractSet是一个实现Set接口的抽象类，Set接口有三个具体实现类，分别是散列集HashSet、链式散列集LinkedHashSet和树形集TreeSet。
散列集HashSet
散列集HashSet是一个用于实现Set接口的具体类，可以使用它的无参构造方法来创建空的散列集，也可以由一个现有的集合创建散列集。在散列集中，有两个名词需要关注，初始容量和客座率。客座率是确定在增加规则集之前，该规则集的饱满程度，当元素个数超过了容量与客座率的乘积时，容量就会自动翻倍。
关于java集合树状和java集合结构图的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。