【恋上数据结构与算法 第二季】【04】图-基础实现_遍历_拓扑排序

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

持续学习&持续更新中…

学习态度：脚踏实地

【恋上数据结构与算法 第二季】【04】图-基础实现_遍历_拓扑排序

代码实现图时并没有采用传统的邻接矩阵或者邻接表，因为它们都太复杂、太麻烦了。
代码实现采用了一种比较折中的方案，比较偏向于邻接表。

代码实现图时，一般实现为有向图，因为无向图可以用有向图来表达。

图的实现方案

在这里插入图片描述

邻接矩阵

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

邻接表

邻接表只需要一个一维数组

在这里插入图片描述

在这里插入图片描述

图的基础接口

在这里插入图片描述

public interface Graph<V, E> {
    int vertexSize(); // 顶点的数量
    int edgeSize(); // 边的数量

    void addVertex(V v); // 添加一个顶点
    void removeVertex(V v); // 删除一个顶点

    void addEdge(V from, V to); // 添加一条边
    void addEdge(V from, V to, E weight); // 添加一条边（带权值）
    void removeEdge(V from, V to); // 删除一条边
}

顶点、边的定义

在这里插入图片描述

在这里插入图片描述

public class ListGraph<V, E> implements Graph<V, E> {
    // 顶点
    private static class Vertex<V, E> {
        V value; // 顶点存储的元素
        Set<Edge<V, E>> inEdges = new HashSet<>(); // 以该顶点为终点的边（到达该顶点的边）
        Set<Edge<V, E>> outEdges = new HashSet<>(); // 以该顶点为起点的边（从该顶点出发的边）

        Vertex(V value) {
            this.value = value;
        }

        @Override
        public boolean equals(Object o) {
            Vertex<V, E> vertex = (Vertex<V, E>) o;
            return Objects.equals(value, vertex.value);
        }

        @Override
        public int hashCode() {
            return value != null ? value.hashCode() : 0;
        }

        @Override
        public String toString() {
            return value == null ? "null" : value.toString();
        }
    }

    // 边
    private static class Edge<V, E> {
        E weight; // 边的权值
        Vertex<V, E> from; // 这条边从哪个顶点出发
        Vertex<V, E> to; // 这条边要到达哪个顶点

        Edge(Vertex<V, E> from, Vertex<V, E> to, E weight) {
            this.from = from;
            this.to = to;
            this.weight = weight;
        }

        @Override
        public boolean equals(Object o) {
            Edge<V, E> edge = (Edge<V, E>) o;
            return from.equals(edge.from) && to.equals(edge.to);
        }

        @Override
        public int hashCode() {
            int result = 0;
            result = 31 * result + from.hashCode();
            result = 31 * result + to.hashCode();
            return result;
        }

        @Override
        public String toString() {
            return "Edge{" +
                    "from=" + from +
                    ", to=" + to +
                    ", weight=" + weight +
                    '}';
        }
    }
}

图的基础实现

public class ListGraph<V, E> implements Graph<V, E> {
    private final Map<V, Vertex<V, E>> vertices = new HashMap<>();
    private final Set<Edge<V, E>> edges = new HashSet<>();

    public void print() {
        System.out.println("顶点：");
        vertices.forEach((k, v) -> {
            System.out.println(k);
            System.out.println("in:");
            System.out.println(v.inEdges);
            System.out.println("out:");
            System.out.println(v.outEdges);
            System.out.println("---------------------");
        });
        System.out.println("边：");
        edges.forEach(System.out::println);
    }

    @Override
    public int vertexSize() {
        return vertices.size();
    }

    @Override
    public int edgeSize() {
        return edges.size();
    }

    @Override
    public void addVertex(V v) {
        if (vertices.containsKey(v)) return;
        vertices.put(v, new Vertex<>(v));
    }

    @Override
    public void removeVertex(V v) {
//        Vertex<V, E> vertex = vertices.get(v);
//        if (null == vertex) return;
        final Vertex<V, E> removeVertex = vertices.remove(v);
        if (null == removeVertex) return;

        for (Iterator<Edge<V, E>> iterator = removeVertex.outEdges.iterator(); iterator.hasNext(); ) {
            final Edge<V, E> edge = iterator.next();
            edges.remove(edge);
            edge.to.inEdges.remove(edge);
//            iterator.remove();
        }
//        removeVertex.outEdges.clear();
        removeVertex.outEdges = null;
        for (Iterator<Edge<V, E>> iterator = removeVertex.inEdges.iterator(); iterator.hasNext(); ) {
            final Edge<V, E> edge = iterator.next();
            edges.remove(edge);
            edge.from.outEdges.remove(edge);
//            iterator.remove();
        }
//        removeVertex.inEdges.clear();
        removeVertex.inEdges = null;
    }

    @Override
    public void addEdge(V from, V to) {
        addEdge(from, to, null);
    }

    // 如果发现某个顶点不存在那么需要创建该顶点
    @Override
    public void addEdge(V from, V to, E weight) {
        Vertex<V, E> fromVertex = vertices.get(from);
        Vertex<V, E> toVertex = vertices.get(to);
        if (fromVertex == null) {
            fromVertex = new Vertex<>(from);
            vertices.put(from, fromVertex);
        }
        if (toVertex == null) {
            toVertex = new Vertex<>(to);
            vertices.put(to, toVertex);
        }
        Edge<V, E> edge = new Edge<>(fromVertex, toVertex, weight);
        if (fromVertex.outEdges.remove(edge)) { // 如果已经存在这条边了
            toVertex.inEdges.remove(edge);
            edges.remove(edge);
        }
        fromVertex.outEdges.add(edge);
        toVertex.inEdges.add(edge);
        edges.add(edge);
    }

    @Override
    public void removeEdge(V from, V to) {
        Vertex<V, E> fromVertex = vertices.get(from);
        Vertex<V, E> toVertex = vertices.get(to);
        if (fromVertex == null || toVertex == null) {
            return;
        }
        Edge<V, E> edge = new Edge<>(fromVertex, toVertex, null);
        if (edges.remove(edge)) { // 如果存在这条边的话，才需要删除
            toVertex.inEdges.remove(edge);
            fromVertex.outEdges.remove(edge);
        }
    }

    // 顶点
    private static class Vertex<V, E> {
        V value; // 顶点存储的元素
        Set<Edge<V, E>> inEdges = new HashSet<>(); // 以该顶点为终点的边（到达该顶点的边）
        Set<Edge<V, E>> outEdges = new HashSet<>(); // 以该顶点为起点的边（从该顶点出发的边）

        Vertex(V value) {
            this.value = value;
        }

        @Override
        public boolean equals(Object o) {
            Vertex<V, E> vertex = (Vertex<V, E>) o;
            return Objects.equals(value, vertex.value);
        }

        @Override
        public int hashCode() {
            return value != null ? value.hashCode() : 0;
        }

        @Override
        public String toString() {
            return value == null ? "null" : value.toString();
        }
    }

    // 边
    private static class Edge<V, E> {
        E weight; // 边的权值
        Vertex<V, E> from; // 这条边从哪个顶点出发
        Vertex<V, E> to; // 这条边要到达哪个顶点

        Edge(Vertex<V, E> from, Vertex<V, E> to, E weight) {
            this.from = from;
            this.to = to;
            this.weight = weight;
        }

        @Override
        public boolean equals(Object o) {
            Edge<V, E> edge = (Edge<V, E>) o;
            return from.equals(edge.from) && to.equals(edge.to);
        }

        @Override
        public int hashCode() {
            int result = 0;
            result = 31 * result + from.hashCode();
            result = 31 * result + to.hashCode();
            return result;
        }

        @Override
        public String toString() {
            return "Edge{" +
                    "from=" + from +
                    ", to=" + to +
                    ", weight=" + weight +
                    '}';
        }
    }
}

图的遍历

在这里插入图片描述

广度优先搜索

使用广度优先搜索遍历图时，从不同的顶点出发，遍历到的结果是不一样的（需要注意的是，有的顶点有时是遍历不到的）

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

    // 广度优先搜索
    @Override
    public void bfs(V begin) {
        final Vertex<V, E> beginVertex = vertices.get(begin);
        if (null == beginVertex) return;

        Queue<Vertex<V, E>> queue = new LinkedList<>();
        Set<Vertex<V, E>> set = new HashSet<>();
        queue.offer(beginVertex);
        set.add(beginVertex);

        while (!queue.isEmpty()) {
            final Vertex<V, E> vertex = queue.poll();

            System.out.println(vertex); // 这里的遍历只是简单的打印一下顶点

            for (Edge<V, E> edge : vertex.outEdges) {
                if (set.contains(edge.to)) continue;
                queue.offer(edge.to);
                set.add(edge.to);
            }
        }
    }

深度优先搜索

使用深度优先搜索遍历图时，从不同的顶点出发，与广度优先搜索一样，遍历到的结果也会是不一样的（需要注意的是，有的顶点有时是遍历不到的）；

使用深度优先搜索遍历图时，从相同的顶点出发进行遍历，也会有很多条路径可以走。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

    // 深度优先搜索——递归实现
    @Override
    public void dfs(V begin) {
        final Vertex<V, E> beginVertex = vertices.get(begin);
        if (null == beginVertex) return;
        dfs(beginVertex, new HashSet<>());
    }

    private void dfs(Vertex<V, E> vertex, Set<Vertex<V, E>> set) {
        System.out.println(vertex);
        set.add(vertex);
        for (Edge<V, E> edge : vertex.outEdges) {
            if (set.contains(edge.to)) continue;
            dfs(edge.to, set);
        }
    }

在这里插入图片描述

在这里插入图片描述

    // 深度优先搜索——非递归实现
    @Override
    public void dfs(V begin) {
        final Vertex<V, E> beginVertex = vertices.get(begin);
        if (null == beginVertex) return;

        Set<Vertex<V, E>> set = new HashSet<>();
        Stack<Vertex<V, E>> stack = new Stack<>();
        stack.push(beginVertex);
        set.add(beginVertex);
        System.out.println(beginVertex);
        while (!stack.isEmpty()) {
            final Vertex<V, E> vertex = stack.pop();
            for (Edge<V, E> edge : vertex.outEdges) {
                if (set.contains(edge.to)) continue;
                stack.push(edge.from);
                stack.push(edge.to);
                set.add(edge.to);
                System.out.println(edge.to);
                break;
            }
        }
    }

修改遍历接口

public interface Graph<V, E> {
    int vertexSize(); // 顶点的数量
    int edgeSize(); // 边的数量
    void addVertex(V v); // 添加一个顶点
    void removeVertex(V v); // 删除一个顶点
    void addEdge(V from, V to); // 添加一条边 // 如果发现某个顶点不存在那么自动创建该顶点
    void addEdge(V from, V to, E weight); // 添加一条边（带权值） // 如果发现某个顶点不存在那么自动创建该顶点
    void removeEdge(V from, V to); // 删除一条边
    
//    void bfs(V begin); // 广度优先搜索遍历
//    void dfs(V begin); // 深度优先搜索遍历
    void bfs(V begin, Visitor<V> visitor); // 广度优先搜索遍历
    void dfs(V begin, Visitor<V> visitor); // 深度优先搜索遍历
    interface Visitor<V> {
        void vertex(V v);
    }
}

    // 广度优先搜索
    @Override
    public void bfs(V begin, Visitor<V> visitor) {
        if (null == visitor) return;
        final Vertex<V, E> beginVertex = vertices.get(begin);
        if (null == beginVertex) return;

        Queue<Vertex<V, E>> queue = new LinkedList<>();
        Set<Vertex<V, E>> set = new HashSet<>();
        queue.offer(beginVertex);
        set.add(beginVertex);
        while (!queue.isEmpty()) {
            final Vertex<V, E> vertex = queue.poll();
            visitor.vertex(vertex.value);
            for (Edge<V, E> edge : vertex.outEdges) {
                if (set.contains(edge.to)) continue;
                queue.offer(edge.to);
                set.add(edge.to);
            }
        }
    }

    // 深度优先搜索——非递归实现
    @Override
    public void dfs(V begin, Visitor<V> visitor) {
        if (null == visitor) return;
        final Vertex<V, E> beginVertex = vertices.get(begin);
        if (null == beginVertex) return;

        Set<Vertex<V, E>> set = new HashSet<>();
        Stack<Vertex<V, E>> stack = new Stack<>();
        stack.push(beginVertex);
        set.add(beginVertex);
        visitor.vertex(beginVertex.value);
        while (!stack.isEmpty()) {
            final Vertex<V, E> vertex = stack.pop();
            for (Edge<V, E> edge : vertex.outEdges) {
                if (set.contains(edge.to)) continue;
                stack.push(edge.from);
                stack.push(edge.to);
                set.add(edge.to);
                visitor.vertex(edge.to.value);
                break;
            }
        }
        
	    // 深度优先搜索——递归实现
	    public void dfs2(V begin, Visitor<V> visitor) {
	        if (null == visitor) return;
	        final Vertex<V, E> beginVertex = vertices.get(begin);
	        if (null == beginVertex) return;
	        dfs2(beginVertex, new HashSet<>(), visitor);
	    }
	
	    private void dfs2(Vertex<V, E> vertex, Set<Vertex<V, E>> set, Visitor<V> visitor) {
	        visitor.vertex(vertex.value);
	        set.add(vertex);
	        for (Edge<V, E> edge : vertex.outEdges) {
	            if (set.contains(edge.to)) continue;
	            dfs2(edge.to, set, visitor);
	        }
	    }
    }

如果想要在遍历的过程中可以停止（退出）遍历的话：

    void bfs(V begin, Visitor<V> visitor); // 广度优先搜索遍历
    void dfs(V begin, Visitor<V> visitor); // 深度优先搜索遍历
// 可以停止遍历
    interface Visitor<V> {
        boolean vertex(V v); // 返回true，就终止遍历
    }

// 可以停止遍历

    // 广度优先搜索
    @Override
    public void bfs(V begin, Visitor<V> visitor) {
        if (null == visitor) return;
        final Vertex<V, E> beginVertex = vertices.get(begin);
        if (null == beginVertex) return;

        Queue<Vertex<V, E>> queue = new LinkedList<>();
        Set<Vertex<V, E>> set = new HashSet<>();
        queue.offer(beginVertex);
        set.add(beginVertex);
        while (!queue.isEmpty()) {
            final Vertex<V, E> vertex = queue.poll();
            if (visitor.vertex(vertex.value)) return;
            for (Edge<V, E> edge : vertex.outEdges) {
                if (set.contains(edge.to)) continue;
                queue.offer(edge.to);
                set.add(edge.to);
            }
        }
    }

    // 深度优先搜索——非递归实现
    @Override
    public void dfs(V begin, Visitor<V> visitor) {
        if (null == visitor) return;
        final Vertex<V, E> beginVertex = vertices.get(begin);
        if (null == beginVertex) return;

        Set<Vertex<V, E>> set = new HashSet<>();
        Stack<Vertex<V, E>> stack = new Stack<>();
        stack.push(beginVertex);
        set.add(beginVertex);
        if (visitor.vertex(beginVertex.value)) return;
        while (!stack.isEmpty()) {
            final Vertex<V, E> vertex = stack.pop();
            for (Edge<V, E> edge : vertex.outEdges) {
                if (set.contains(edge.to)) continue;
                stack.push(edge.from);
                stack.push(edge.to);
                set.add(edge.to);
                if (visitor.vertex(edge.to.value)) return;
                break;
            }
        }
    }

AOV网

作业：自学《AOV网络》

在这里插入图片描述

在这里插入图片描述

拓扑排序

在这里插入图片描述

在这里插入图片描述

卡恩算法的思路是对的，但代码实现时，我们肯定不能将顶点删掉，因为这样会破坏原有的图结构，所以我们代码使用卡恩算法实现拓扑排序时，应该变通一下：

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

    // 使用卡恩算法对DAG进行拓扑排序
    @Override
    public List<V> topologicalSort() {
        List<V> list = new ArrayList<>(); // list用来存放遍历结果，返回给使用者
        Queue<Vertex<V, E>> queue = new LinkedList<>(); // queue用来存放入度为0的顶点
        Map<Vertex<V, E>, Integer> map = new HashMap<>(); // 顶点的入度表

        // 初始化入度表和queue（将度为0的节点都放入队列）
        vertices.forEach((v, vertex) -> {
            int inSize = vertex.inEdges.size();
            if (inSize == 0) queue.offer(vertex);
            else
                // 初始化入度表时，没有必要将入度为0的顶点放入入度表中
                map.put(vertex, inSize);
        });

        while (!queue.isEmpty()) {
            Vertex<V, E> vertex = queue.poll();
            list.add(vertex.value);
            vertex.outEdges.forEach(edge -> {
                Integer integer = map.get(edge.to);
                integer--;
                if (integer == 0)
                    // 将这个顶点入队后，就不用更新该顶点的入度了
                    queue.offer(edge.to);
                else map.put(edge.to, integer);
            });
        }

        return list;
    }

测试：

在这里插入图片描述

public class Data {
    public static final Object[][] TOPO = {
            {0, 2},
            {1, 0},
            {2, 5}, {2, 6},
            {3, 1}, {3, 5}, {3, 7},
            {5, 7},
            {6, 4},
            {7, 6}
    };
}

    /**
     * 有向图
     */
    private static Graph<Object, Double> directedGraph(Object[][] data) {
        Graph<Object, Double> graph = new ListGraph<>();
        for (Object[] edge : data) {
            if (edge.length == 1) {
                graph.addVertex(edge[0]);
            } else if (edge.length == 2) {
                graph.addEdge(edge[0], edge[1]);
            } else if (edge.length == 3) {
                double weight = Double.parseDouble(edge[2].toString());
                graph.addEdge(edge[0], edge[1], weight);
            }
        }
        return graph;
    }

    /**
     * 无向图
     */
    private static Graph<Object, Double> undirectedGraph(Object[][] data) {
        Graph<Object, Double> graph = new ListGraph<>();
        for (Object[] edge : data) {
            if (edge.length == 1) {
                graph.addVertex(edge[0]);
            } else if (edge.length == 2) {
                graph.addEdge(edge[0], edge[1]);
                graph.addEdge(edge[1], edge[0]);
            } else if (edge.length == 3) {
                double weight = Double.parseDouble(edge[2].toString());
                graph.addEdge(edge[0], edge[1], weight);
                graph.addEdge(edge[1], edge[0], weight);
            }
        }
        return graph;
    }

    private static void testTopologicalSort() {
        Graph<Object, Double> graph = directedGraph(Data.TOPO);
        graph.topologicalSort().forEach(System.out::println);
    }
    
    public static void main(String[] args) {
        testTopologicalSort();
    }

参考

小码哥李明杰老师课程: 恋上数据结构与算法 第二季.

本文完，感谢您的关注支持！

lpruoyu
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
恋上数据结构与算法第二季课件pdf
10-29
恋上数据结构与算法第二季课件,恋上数据结构第二季主要是对算法进行详解,如排序,查并集,图,递归,回溯,贪心,分治,动态规划等等
恋上数据结构与算法第二季
mhx123456789的博客
11-12 174
视频： 01.冒泡、选择、堆排序.mp4 02.插入排序.mp4 03.归并排序.mp4 04.快速、希尔排序.mp4 05.计数、基数、桶排序.mp4 06.并查集.mp4 07.图、BFS、DFS、拓扑排序.mp4 08.kruskal、prim.mp4 09.dijkstra、bellman-ford、floyd.mp4 10.KMP、BM、KR、Sunday.mp4 11.Dijkstra.mp4 12.Dijkstra完善、Bellman-Ford.mp4 13.递归、回溯.mp4 14.尾调用.
JVM的GC详解
Anjihua的博客
11-06 297
垃圾回收机制就要解决这几个问题： 1、那些内存可以回收？ 2、什么时候回收？ 3、如何回收？ 判断那些内存可以回收： 什么时候回收： 如何回收： ...
【恋上数据结构与算法 第二季】【05】图-最小生成树
Keep Reading Keep Writing Keep Thinking
03-13 1100
持续学习&持续更新中… 学习态度：脚踏实地 【恋上数据结构与算法 第二季】【05】图-最小生成树生成树最小生成树切分定理Prim算法Prim算法实现Kruskal算法Kruskal算法实现注意参考 生成树 用最少的边将图的所有顶点连通起来，使该图依旧是一个连通图，我们就称之为生成树（支撑树） 一个连通图的生成树（支撑树）可以有很多颗 最小生成树 一个连通图可以有很多颗生成树 如果某个生成树的所有边的权值之和在众多生成树的所有边的权值之和之中是最小的，那么该生成树就是最小生成树 切分.
恋上数据结构与算法
qq_42832437的博客
05-30 545
恋上数据结构与算法第一季 今天是5-30号，距离考研还有204天。感觉时间过得真快，马上就六月份了。想用笔记的形式，完整得记录下自己的学习过程。我的想法就是学这个视频，相当于第二遍学习数据结构，现在目前的一个计划就是在7月份一定一定要把408过一边。作为一个跨考生确实学习的还是有点吃力。但是一定要努力呀，不服输，不认输。 不知道能不能看完第二季，第二季确实有点多，但是还是尽量地看看。送给自己的一段话：努力的意义是当所有美好的事情奔我而来的时候，我能够坦然地张开双臂拥抱它，并且觉得我很值得 ...
恋上数据结构与算法(第一季)-MJ大神精选
07-18
恋上数据结构与算法(第一季)-MJ大神精选
恋上数据结构与算法课件.rar
11-23
主要针对复杂度、链表、栈、队列、二叉树、B树、红黑树、集合。课件包含图片展示，容易理解，爱，就码上行动。
tudebianli.rar_数据结构 图_遍历word
09-22
数据结构与算法 图的遍历 算法
DFS.rar_数据结构代码_遍历算法
09-23
数据结构经典算法，宽度优先遍历，c语言源代码。
恋上数据结构与算法_恋上数据结构与算法(1-3)
weixin_31749207的博客
02-05 421
目录什么是算法算法好坏的评判标准实例讲解时间复杂度斐波那契数算法剖析算法的优化方向一 什么是算法引用百度百科对算法的解释 算法算法(Algorithm)是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算...
《恋上算法第一季》PPT课件.rar
05-12
小码哥 算法课程第一季的配套教材 课件视频来源：https://space.bilibili.com/325538782/
恋上数据结构课件.rar
07-29
小码哥恋上数据结构课程课件pdf格式 01-学前须知.pdf 02-开发环境，pdf 03-复杂度.pdf 04-动态数组.pdf 05-链表.pdf 06-栈.pdf 07-队列.pdf 08-二叉树.pdf 09-二又搜索树.pdf 10-平衡二又搜索树.pdf 11-AVL树.pdf 12-B树.pdf 园13-红黑树.pdf 14-集合.pdf 15-映射.pdf 16-哈希表.pdf 圆17-二叉堆.pdf 18-优先级队列.pdf 19-哈夫曼树.pdf 20-Trie.pdf 21-总结.pdf
恋上数据结构与算法_恋上数据结构与算法笔记（一）：数据结构与算法基本知识...
weixin_39844267的博客
12-20 214
什么是数据结构数据结构是计算机存储、组织数据的方式，大致划分为：线性结构数组、链表、栈、队列、哈希表树形结构AVL树、红黑树、B树、堆、Trie、哈夫曼树、并查集图形结构邻接矩阵、邻接表什么是算法基本概念算法是用于解决特定问题的一系列的执行步骤。解决同一个问题，可能有多种算法，应该选用最易读的，并且执行效率最高的代码。以下代码示例都是算法：计算两个数的和：public int plus(int a...
MJ恋上数据结构（第1季 + 第2季）笔记
流星的博客
07-21 682
恋上数据结构完整笔记（第1季 + 第2季）
恋上数据结构与算法：集合(十九)
zzq的博客
07-15 322
文章目录 (一)集合（Set）：简介 (二)集合（Set）：ListSet (三)集合（Set）：TreeSet (四)集合（Set）：复杂度分析 (五)集合（Set）：TreeSet的局限性 (六)集合（Set）：作业题 (一)集合（Set）：简介 (二)集合（Set）：ListSet 我们用链表实现集合（ListSet） 注意：之前的动态数组和链表有索引，可以使用for循环遍历，但集合没有索引，需要提供遍历接口 首先写一个Set接口，如下： public interface Set<E>
恋上数据结构与算法第一季
qq_42832437的博客
05-30 575
01. 复杂度 02. 动态数组 03. 链表 04. 栈 05. 队列 06. 二叉树 07. 二叉搜索树 08. 平衡二叉树 09. AVL树 10. B树 11. 红黑树 12. 集合 13. 映射 14. 哈希表 15. 二叉堆 16. 优先级队列 17. 哈夫曼树 18. Trie 19. 总结 ...
恋上数据结构完整笔记（第1季 + 第2季）
热门推荐
萌宅鹿的技术小屋
03-13 2万+
Java 数据结构目录 整理一下。。。 【动态扩容数组】动态扩容数组 ArrayList实现源码（Java、C++） 【链表List】单向链表 SingleLinkedList、双向链表 LinkedList 实现源码 【循环链表CircleList】单向循环链表、双向循环链表以及约瑟夫环问题 【队列Queue】队列 Queue、双端队列 DeQueue、循环队列 CircleQueue、双端循环...
数据结构 | 详解栈实现队列&队列实现栈
最新发布
mooridy的博客
05-17 326
step2：此时非空队列中剩下的唯一一个数就是“栈顶”元素，使用QueueFront进行·取值后，直接进行QueuePop删除。step0.先利用假设法假定非空队列notempty和空队列empty，再利用MyStackEmpty函数对进行修正。step1:将notempty队列中的前size-1个元素依次push到empty队列中，再进行删除，实现移动操作。
USB3.0接口——（2）数据结构
dkmknjk的博客
05-14 1063
在 USB 3.0 及更高版本的 xHCI 协议中，"Rings"、"Transfer Request Block (TRB)" 和 "Transfer Descriptor (TD)" 是用于管理 USB 数据传输和事件的重要概念。
图的遍历 --- 广度优先遍历算法
07-27
广度优先遍历算法（BFS）是一种用于图的遍历的算法。它从图的某个顶点开始，首先访问这个顶点，然后依次访问其相邻的未被访问过的顶点，再依次访问这些顶点的相邻未被访问过的顶点，以此类推，直到所有顶点都被访问...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值