Java数据结构-图的相关笔记总结

最新推荐文章于 2022-02-28 21:17:38 发布
最新推荐文章于 2022-02-28 21:17:38 发布
阅读量297 收藏 3
点赞数 1
分类专栏： 数据结构与算法 文章标签： 算法 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huangjhai/article/details/113749022
版权

文章目录

1. 基本介绍

图是一种数据结构，其中结点可以有零个或多个相邻元素，两个结点之间的连接称为边。结点也可以称为顶点。

关于图的常用概念：
路径：一个顶点到另一个顶点需要经历的边，如下图从B->E的路径有：
(1) B->D->E
(2) B->A->D->E

无向图：顶点之间的连接没有方向，比如A->B，也可以是B->A。
一个基本的无向图结构如下图所示：
在这里插入图片描述
有向图：顶点之间的连接有方向，比如从A到B的路径，只能是A->B，不能是B->A。有向图如图所示：
在这里插入图片描述
带权图：边上带有权值的图，带权图也叫网。带权图示例：
在这里插入图片描述

2. 图的表示方式

图的表示方式有两种：邻接矩阵（二维数组表示）和邻接表（链表表示）

2.1 邻接矩阵

2.1.1 基本介绍

邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵的行（下标用i表示）、列（下标用j表示），(i,j)的值表示横坐标为i的点和纵坐标为j的点是否有连接，1表示有连接，0表示无连接。邻接矩阵示例：
在这里插入图片描述
说明：
标记为0的顶点与1顶点相关联，和5顶点不关联

2.1.2 代码实现

用代码实现邻接矩阵表示下面这个图：
在这里插入图片描述
完整代码：

public class Graph {

    /**
     * 顶点集合
     */
    private ArrayList<String> vertexList;
    /**
     * 存储图对应的邻接矩阵
     */
    private int[][] edges;
    /**
     * 边界的数量
     */
    private int edgeNum;

    public Graph(int n){
        vertexList=new ArrayList<>(n);
        edges=new int[n][n];
        edgeNum=0;
    }

    /**
     * 插入顶点到vertexList
     * @param vertex
     */
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }

    /**
     * 添加边
     * @param v1 顶点在edges的下标
     * @param v2
     * @param weight 1或0，1表示有连接，0表示无连接
     */
    public void insertEdge(int v1,int v2,int weight){
        edges[v1][v2]=weight;
        edges[v2][v1]=weight;
        edgeNum++;
    }

    /**
     * 返回结点的数量
     * @return
     */
    public int getVertexNum(){
        return vertexList.size();
    }

    /**
     * 得到图的边数量
     * @return
     */
    public int getEdgeNum(){
        return edgeNum;
    }

    /**
     * 通过下标获取结点对应的数据
     * @param index
     * @return
     */
    public String getVauleByIndex(int index){
        return vertexList.get(index);
    }

    /**
     * 返回v1和v2之间的权值
     * @param v1
     * @param v2
     * @return
     */
    public int getWeight(int v1, int v2){
        return edges[v1][v2];
    }

    /**
     * 显示矩阵
     */
    public void showGraph(){
        for (int[] edge : edges) {
            System.out.println(Arrays.toString(edge));
        }
    }

    public static void main(String[] args) {
        String[] vertexes={"A","B","C","D","E"};
        int size=5;
        Graph graph = new Graph(size);
        //插入顶点
        for (String vertex : vertexes) {
            graph.insertVertex(vertex);
        }
        //添加边
        //A-B
        graph.insertEdge(0,1,1);
        //A-C
        graph.insertEdge(0,2,1);
        //B-C
        graph.insertEdge(1,2,1);
        //B-D
        graph.insertEdge(1,3,1);
        //B-E
        graph.insertEdge(1,4,1);
        graph.showGraph();
    }
}

查看控制台输出是否正确表示给出的图，如下

[0, 1, 1, 0, 0]
[1, 0, 1, 1, 1]
[1, 1, 0, 0, 0]
[0, 1, 0, 0, 0]
[0, 1, 0, 0, 0]

2.2 邻接表

2.2.1 基本介绍

邻接表由数组+链表组成，邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费。作为对比，因为邻接矩阵有n个顶点就需要为每个顶点都分配n个空间，由于大多数情况下，很多顶点不相连接，因此造成了内存空间浪费。

邻接表的示例图：
在这里插入图片描述
说明：标号为0的结点的相关联的结点为 1 、2、3、4；标号为1的结点的相关联结点为0、4；标号为2的结点相关联的结点为 0、4、5。

2.2.2 代码实现

用代码实现邻接表表示下面这个图：
在这里插入图片描述
顶点"A",“B”,“C”,“D”,“E”,分别使用0，1，2，3，4，5表示

新建类用于表示图的顶点

class VertexNode{
    public int data;
    public VertexNode next;

    public VertexNode(int data) {
        this.data = data;
    }

    public VertexNode(int data, VertexNode next) {
        this.data = data;
        this.next = next;
    }

    @Override
    public String toString() {
        return "VertexNode{" +
                "data=" + data+"}->";
    }
}

完成代码实现：

public class Graph {

    /**
     * 顶点集合
     */
    private ArrayList<String> vertexList;
    /**
     * 存储图对应的邻接矩阵
     */
    private VertexNode[] edges;
    /**
     * 边界的数量
     */
    private int edgeNum;

    public Graph02(int n){
        vertexList=new ArrayList<>(n);
        edges=new VertexNode[n];
        edgeNum=0;
    }

    /**
     * 插入顶点到vertexList
     * @param vertex
     */
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }


    /**
     *插入边
     * @param index  数组下标
     * @param vertex 连接的顶点
     */
    public void insertEdge(int index,VertexNode vertex){
        if (edges[index]==null){
            edges[index]=vertex;
        }else{
            VertexNode temp=edges[index];
            while (temp.next!=null){
                temp=temp.next;
            }
            temp.next=vertex;
        }
    }

    /**
     *
     * @param v1 顶点1的下标
     * @param v2 顶点2的下标
     */
    public void insertEdge(int v1,int v2){
        insertEdge(v1,new VertexNode(v2));
        insertEdge(v2,new VertexNode(v1));
        edgeNum++;
    }

    /**
     * 返回结点的数量
     * @return
     */
    public int getVertexNum(){
        return vertexList.size();
    }

    /**
     * 得到图的边数量
     * @return
     */
    public int getEdgeNum(){
        return edgeNum;
    }

    /**
     * 通过下标获取结点对应的数据
     * @param index
     * @return
     */
    public String getVauleByIndex(int index){
        return vertexList.get(index);
    }

    /**
     * 返回顶点v1和顶点v2之间的权值，1表示有连接，0表示无连接
     * @param v1
     * @param v2
     * @return
     */
    public int getWeight(int v1,int v2) {
        if (v1>=vertexList.size()||v2>=vertexList.size()){
            return 0;
        }
        if (edges[v1]==null){
            return 0;
        }
        VertexNode temp=edges[v1];
        while (temp!=null){
            if (temp.data==v2){
                return 1;
            }
            temp=temp.next;
        }
        return 0;
    }

    /**
     *
     */
    public void showVertexNode(VertexNode vertexNode){
        VertexNode temp=vertexNode;
        while (temp!=null){
            System.out.print(temp.toString());
            temp=temp.next;
        }
    }

    /**
     * 显示矩阵
     */
    public void showGraph(){
        int i=0;
        for (VertexNode edge : edges) {
            if (edge!=null){
                System.out.print(i++ +": ");
            }
            showVertexNode(edge);
            System.out.println();
        }
    }

    public static void main(String[] args) {
        String[] vertexes={"A","B","C","D","E"};
        int size=5;
        Graph graph = new Graph02(size);
        //插入顶点
        for (String vertex : vertexes) {
            graph.insertVertex(vertex);
        }
        //添加边
        //A-B,
        graph.insertEdge(0,1);
        //A-C
        graph.insertEdge(0,2);
        //B-C
        graph.insertEdge(1,2);
        //B-D
        graph.insertEdge(1,3);
        //B-E
        graph.insertEdge(1,4);
        System.out.println("该图的边的数量："+graph.getEdgeNum());
        System.out.println("该图的结点量："+graph.getVertexNum());
        graph.showGraph();
    }
}

控制台输出，查看是否正确表示出图：

该图的边的数量：5
改图的结点数量：5
0: VertexNode{data=1}->VertexNode{data=2}->
1: VertexNode{data=0}->VertexNode{data=2}->VertexNode{data=3}->VertexNode{data=4}->
2: VertexNode{data=0}->VertexNode{data=1}->
3: VertexNode{data=1}->
4: VertexNode{data=1}->

3. 图的遍历

所谓图的遍历，即是对结点的访问。一个图有那么多个结点，如何遍历这些结点，需要特定策略，一般有两种访问策略:
(1) 深度优先遍历
(2) 广度优先遍历

3.1 深度优先遍历（DFS）

3.1.1 基本介绍

深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点， 可以这样理解：每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。

我们可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。显然，深度优先搜索是一个递归的过程。

3.1.2 代码实现

以邻接矩阵作为图的表示，深度优先遍历算法实现步骤如下：
(1) 访问初始结点v，并标记结点v为已访问。
(2) 查找结点v的第一个未访问过的邻接结点w。
(3) 若w存在，则执行步骤4，如果w不存在，则回到第1步，将从v的下一个结点继续。
(4) 对w进行深度优先遍历递归（即把w当做另一个v)，然后进行步骤1、2、3。
(5) 遍历完v的第一个邻接结点w，查找结点v的下一个邻接结点，重复进行步骤3、4，直到遍历完所有的结点。

下面要使用邻接矩阵表示的图：
在这里插入图片描述
深度优先遍历实现的关键代码：

    /**
     * 从下标为0的顶点开始遍历
     */
    private void dfs(){
        for (int i = 0; i < isVisited.length; i++) {
            isVisited[i]= false;
        }
        //因为可能存在无连接的结点，所以需要遍历每个结点
        for (int i = 0; i < getVertexNum(); i++) {
            if (!isVisited[i]){
                dfs(i);
            }
        }
    }

    /**
     * 深度优先遍历算法
     * @param i 顶点的下标
     */
    private void dfs(int i){
        System.out.print(getValueByIndex(i)+"=>");
        //标记为已经访问过
        isVisited[i]=true;
        //查找下一个邻接结点w
        int w=getFirstNeighbor(i);
        while (w!=-1){
            //如果没有访问过,就继续往下遍历
            dfs(w);
            //如果w被访问过了，访问v下一个邻接结点
            w=getNextNeighbor(i,w);
        }
    }

完整代码：

public class Graph {

    /**
     * 顶点集合
     */
    private ArrayList<String> vertexList;
    /**
     * 存储图对应的邻接矩阵
     */
    private int[][] edges;
    /**
     * 边界的数量
     */
    private int edgeNum;
    /**
     * 结点是否被遍历到
     */
    private boolean[] isVisited;

    public Graph(int n){
        vertexList=new ArrayList<>(n);
        edges=new int[n][n];
        edgeNum=0;
        isVisited=new boolean[n];
    }

    /**
     * 插入顶点到vertexList
     * @param vertex
     */
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }

    /**
     * 添加边
     * @param v1 顶点在edges的下标
     * @param v2
     * @param weight 1或0，1表示有连接，0表示无连接
     */
    public void insertEdge(int v1,int v2,int weight){
        edges[v1][v2]=weight;
        edges[v2][v1]=weight;
        edgeNum++;
    }

    /**
     * 从下标为0的顶点开始遍历
     */
    private void dfs(){
        for (int i = 0; i < isVisited.length; i++) {
            isVisited[i]= false;
        }
        //因为可能存在无连接的结点，所以需要遍历每个结点
        for (int i = 0; i < getVertexNum(); i++) {
            if (!isVisited[i]){
                dfs(i);
            }
        }
    }

    /**
     * 深度优先遍历算法
     * @param i 顶点的下标
     */
    private void dfs(int i){
        System.out.print(getValueByIndex(i)+"=>");
        //标记为已经访问过
        isVisited[i]=true;
        //查找下一个邻接结点w
        int w=getFirstNeighbor(i);
        while (w!=-1){
            //如果没有访问过,就继续往下遍历
            dfs(w);
            //如果w被访问过了，访问v下一个邻接结点
            w=getNextNeighbor(i,w);
        }
    }

    /**
     * 获取index的第一个未访问过的邻接结点
     * @param index
     * @return
     */
    private int getFirstNeighbor(int index) {
        for (int i = 0; i < edges.length; i++) {
            if (edges[index][i]>0&&!isVisited[i]){
                return i;
            }
        }
        return -1;
    }

    /**
     * 根据上一个邻接结点的下标edgeIndex，获取结点vertexIndex的下一个未访问过的邻接结点
     * @param vertexIndex
     * @param edgeIndex
     * @return
     */
    private int getNextNeighbor(int vertexIndex,int edgeIndex){
        for (int i = edgeIndex+1; i < edges.length; i++) {
            if (edges[vertexIndex][i]>0&&!isVisited[i]){
                return i;
            }
        }
        return -1;
    }

    /**
     * 返回结点的数量
     * @return
     */
    public int getVertexNum(){
        return vertexList.size();
    }

    /**
     * 得到图的边数量
     * @return
     */
    public int getEdgeNum(){
        return edgeNum;
    }

    /**
     * 通过下标获取结点对应的数据
     * @param index
     * @return
     */
    public String getValueByIndex(int index){
        return vertexList.get(index);
    }

    /**
     * 返回v1和v2之间的权值
     * @param v1
     * @param v2
     * @return
     */
    public int getWeight(int v1, int v2){
        return edges[v1][v2];
    }

    /**
     * 显示矩阵
     */
    public void showGraph(){
        for (int[] edge : edges) {
            System.out.println(Arrays.toString(edge));
        }
    }

    public static void main(String[] args) {
        String[] vertexes={"1","2","3","4","5","6","7","8"};

        int size=8;
        Graph graph = new Graph(size);
        //插入顶点
        for (String vertex : vertexes) {
            graph.insertVertex(vertex);
        }
        //添加边
        graph.insertEdge(0, 1, 1);
        graph.insertEdge(0, 2, 1);
        graph.insertEdge(1, 3, 1);
        graph.insertEdge(1, 4, 1);
        graph.insertEdge(3, 7, 1);
        graph.insertEdge(4, 7, 1);
        graph.insertEdge(2, 5, 1);
        graph.insertEdge(2, 6, 1);
        graph.insertEdge(5, 6, 1);
        graph.showGraph();
        System.out.println("深度优先遍历：");
        graph.dfs();
    }
}

控制台输出，图的邻接矩阵表示和深度优先遍历结果：

[0, 1, 1, 0, 0, 0, 0, 0]
[1, 0, 0, 1, 1, 0, 0, 0]
[1, 0, 0, 0, 0, 1, 1, 0]
[0, 1, 0, 0, 0, 0, 0, 1]
[0, 1, 0, 0, 0, 0, 0, 1]
[0, 0, 1, 0, 0, 0, 1, 0]
[0, 0, 1, 0, 0, 1, 0, 0]
[0, 0, 0, 1, 1, 0, 0, 0]
深度优先遍历：
1=>2=>4=>8=>5=>3=>6=>7=>

3.2 广度优先遍历(BFS)

3.2.1 基本介绍

图的广度优先搜索(Broad First Search) 。类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来访问这些结点的邻接结点。

3.2.2 代码实现

以邻接矩阵作为图的表示，广度优先遍历算法实现步骤如下：

(1)访问初始结点v并标记结点v为已访问。
(2)结点v入队列
(3)当队列非空时，继续执行，否则算法结束。
(4)出队列，取得队头结点u。
(5)查找结点u的第一个未访问过的邻接结点w。
(6)若结点u的邻接结点w不存在，则转到步骤3；否则循环执行以下三个步骤：
6.1 访问结点w并标记为已访问。
6.2 结点w入队列
6.3 查找结点u的继邻接结点w后的下一个未访问的邻接结点w，转到步骤6。

要遍历的图和上面的深度遍历的图相同，广度优先遍历算法的关键代码如下：

  private void bfs(){
        for (int i = 0; i < isVisited.length; i++) {
            isVisited[i]= false;
        }
        //因为可能存在无连接的结点，所以需要遍历每个结点
        for (int i = 0; i < getVertexNum(); i++) {
            if (!isVisited[i]){
                bfs(i);
            }
        }
    }

    /**
     * 广度优先遍历
     * @param i
     */
    private void bfs(int i){
        //表示队列头节点对应的下标
        int u;
        //邻接结点w
        int w;
        //使用LinkedList做队列
        LinkedList<Integer> queue = new LinkedList<>();
        //标记为已访问
        isVisited[i]=true;
        System.out.print(getValueByIndex(i)+"=>");
        //将结点加入队列中
        queue.addLast(i);
        while (!queue.isEmpty()){
             //取出队列头节点的坐标
             u= queue.removeFirst();
             //得到第一个邻接结点
             w=getFirstNeighbor(u);
             //广度优先算法体现，遍历当前结点所有连接的结点，并添加到队列中
             while (w!=-1){
                 System.out.print(getValueByIndex(w)+"=>");
                 //标记为已经访问
                 isVisited[w]=true;
                 queue.addLast(w);
                 w=getNextNeighbor(u,w);
             }
        }
    }

控制台输出，图的邻接矩阵表示和广度优先遍历结果：

[0, 1, 1, 0, 0, 0, 0, 0]
[1, 0, 0, 1, 1, 0, 0, 0]
[1, 0, 0, 0, 0, 1, 1, 0]
[0, 1, 0, 0, 0, 0, 0, 1]
[0, 1, 0, 0, 0, 0, 0, 1]
[0, 0, 1, 0, 0, 0, 1, 0]
[0, 0, 1, 0, 0, 1, 0, 0]
[0, 0, 0, 1, 1, 0, 0, 0]
广度优先遍历：
1=>2=>3=>4=>5=>6=>7=>8=>

笔记总结自：
https://www.bilibili.com/video/BV1E4411H73v
详细介绍深度优先遍历和广度优先遍历：
漫画：深度优先遍历和广度优先遍历

Code0cean
关注
专栏目录
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
深入理解数据结构——图
seek97的博客
08-09 188
#include<iostream> #include<string> using namespace std; struct Graph { int** data; int vertex_num;//顶点数量 int edge_num;//边数 }; //基于邻接矩阵表示的有向带权图的建立算法 void CreateGraph(Graph &g) { int n, first, second; cout << "请输入边的数量"; cin .
Java数据结构——图的总结
NoBug
02-22 552
1. 更新了部分代码。********************** 2. 划出了重点。*************************** 3. 提供了练习源码，数据。************** 4. 下面的内容：查找与排序。************
刷题笔记：Java常用数据结构知识点总结
hutianle的博客
02-28 759
Java数据结构
Java数据结构----图的基础知识
ChangWen的博客
02-20 7688
1、概念 图： 是一种复杂的非线性数据结构。 图的二元组定义：   图 G 由两个集合 V 和 E 组成，记为：   G=(V, E)  其中： V 是顶点的有穷非空集合,   E 是 V 中顶点偶对(称为边)的有穷集。   通常，也将图 G 的顶点集和边集分别记为 V(G) 和 E(G) 。 E(G) 可以是空集。若 E(G) 为空，则图 G 只有顶点而没有边。 有向图：
Java数据结构——图的基本知识
NoBug
02-03 1213
{- 以上是图的基础知识。} {- 本节解释了，以后几天图的相关代码的一些专业名词的英文命名。} {- 下面一天介绍：图的存储。}
韩顺平老师尚硅谷Java数据结构与算法194集笔记
10-12
这是我从B站上看韩老师讲的数据结构与算法后整理的笔记 代码经过运行，欢迎批评指正 有些地方我感觉还是挺难的 大都经过我自己的语言进行描述，韩老师中期的表达可能或多或少也影响可阅读性，望先生们见谅
Java数据结构学习笔记
12-18
### Java数据结构学习笔记知识点详解 #### 一、数据结构与算法基础 1. **数据结构定义** - 数据结构是一门研究组织数据方式的学科，它与编程语言紧密相关，是实现高效程序设计的基础。 - 在软件开发中，合理选择...
数据结构与算法-学习笔记 Java 版.zip
最新发布
01-15
基本操作：针对每种数据结构，定义了一系列基本的操作，包括但不限于插入、删除、查找、更新、遍历等，并分析这些操作的时间复杂度和空间复杂度。 算法： 算法设计：研究如何将解决问题的步骤形式化为一系列指令，...
Java数据结构和算法详细笔记
07-09
3. **队列**：是一种先进先出（FIFO）的数据结构，Java提供了`Queue`接口和相关的实现类，如`LinkedList`和`ArrayDeque`。 4. **栈**：是一种后进先出（LIFO）的数据结构，Java中的`Stack`类实现了栈的功能。 非...
考试必看：数据结构与算法思维导图（Java描述）
05-02
数据结构与算法的思维导图。详细。考试必备。详细。考试必备。详细。考试必备。详细。考试必备。版权所有。
Java数据结构和算法学习笔记
zth13015409853的博客
01-05 1012
Java程序员必须要掌握的几种数据结构和算法
（基于Java）算法笔记——数据结构(图)
Terio的博客
07-30 277
数据结构(图)算法简略记录 1、引言 图是树的升级版（树是相连无相无环图） 有向图 无向图 有循环 无循环 所有节点相连 所有节点不相连 图通常有两种表示方法，假设图中有n个节点，m条边 邻接矩阵： 建立一个 n x n矩阵G，如果第i个节点连向第j个节点，则G[i][j]=1，反之为0 如果图是无向的，则该邻接矩阵一定是对称矩阵，即G[i][j]=G[j][i] 邻接链表： 建立一个大小为n的数组，每个位置i储存一个数组或链表，表示第i个节点连向其他节点 邻接矩阵 比 邻接链表 空间开销
31.java数据结构与算法-图(笔记)
weixin_49053303的博客
03-23 102
一、图的基本介绍
java数据结构图_java总结数据结构和算法
weixin_39586335的博客
02-12 86
数据结构分类：线性结构和非线性结构线性结构包括：数组，链表，队列，栈；非线性结构包括：树，图，表；数组是查询快，插入和删除慢，因为需要对元素移动空间链表是元素可以不连续内存中，是以索引将数据联系起来的，插入和删除快，查询慢队列特点：先进先出，使用场景：多线程阻塞队列管理非常有用数组与链表的区别数组连续，链表不连续(从数据存储形式来说)数组内存静态分配，链表动态分配数组从栈中分配内存。链表从堆中分配...
20172316 2017-2018-2《程序设计与数据结构》课程总结
weixin_30666753的博客
06-24 199
20172316 2017-2018-2《程序设计与数据结构》课程总结 每周作业链接汇总 第一周作业：第一周首次接触Java，主要内容为使用System.out.println()方法（Hello World！），此外还有其他的在网上找的练习例题。 第二周作业：学习更多的类以及基本的运算符号的使用，丰富可以掌握的方法，使程序的功能更加多样化。（Scaner Math） 第三周作业：重点学习Str...
java数据结构课程设计_java数据结构课程设计
weixin_33603681的博客
02-21 1244
华东交大理工学院课程设计(论文)任务书电信分院2009 电子商务专业一班一、课程设计(论文)题目走迷宫二、课程设计(论文)工作自 2011 年6月20 日起至 2011 年6月30 日止。三、课程设计(论文) 地点: 机房四、课程设计(论文)内容要求：1．本课程设计的目的(1)熟练掌握数据结构的基本算法，提高算法设计与分析能力(2)基本掌握面向对象设计基本思路和方法；(3)利用所学的基...
java数据结构
blog
11-11 409
继承图1.Enumeration主要用于遍历其他数据结构Enumeration xxx = c.elements() while (xxx.hasMoreElements()) { System.out.println(xxx.nextElement()); }2.Bitset创建一种特殊类型的数组来保存位值，BitSet中数组大小会随需要增加。BitSet xxx = new B
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值