图结构与高级数据结构的学习笔记一

最新推荐文章于 2024-08-29 22:06:50 发布
最新推荐文章于 2024-08-29 22:06:50 发布
阅读量631 收藏 13
点赞数 23
文章标签： 数据结构 学习 笔记 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59335007/article/details/141688711
版权

  • 学习内容:

    • 图（Graph）：
      • 图的基本概念、表示方法（邻接矩阵、邻接表）。
      • 图的遍历（深度优先搜索DFS、广度优先搜索BFS）。
    • 最短路径算法：
      • Dijkstra算法、Bellman-Ford算法的理解与实现。
    • 最小生成树（MST）：
      • Kruskal算法、Prim算法的理解与实现。

  • 实践:

    • 实现图的基本操作和遍历算法。
    • 用Dijkstra算法解决最短路径问题，理解其在现实世界中的应用。
1. 图的基本概念
  • 定义: 图由**顶点（Vertex）和边（Edge）**组成。顶点表示图中的对象，边表示对象之间的关系。
  • 分类:
    • 有向图: 边有方向性，表示从一个顶点到另一个顶点的单向连接。
    • 无向图: 边没有方向性，表示两个顶点之间的双向连接。
  • 图的度:
    • 出度（Out-degree）: 从某顶点出发的边的数量。
    • 入度（In-degree）: 指向某顶点的边的数量。
2. 图的表示方法

  • 邻接矩阵（Adjacency Matrix）:

    • 用一个二维数组表示图。如果顶点 i 到顶点 j 有边，则矩阵中的元素为 1（或边的权重），否则为 0。
    • 优点: 快速检查两个顶点是否有边。
    • 缺点: 对于稀疏图，浪费空间。

  • 邻接表（Adjacency List）:

    • 每个顶点有一个链表（或数组），链表中存储与该顶点相邻的顶点。
    • 优点: 节省空间，特别是对于稀疏图。
    • 缺点: 检查两个顶点是否有边比较慢。
3. 图的遍历

  • 深度优先搜索（DFS）:

    • 类似于树的先序遍历，沿着每个分支走到底，再回溯到上一个顶点，继续探索其他未访问的分支。
    • 实现: 使用栈（可以通过递归实现）。
    • 时间复杂度: O(V + E)，其中 V 是顶点数，E 是边数。

  • 广度优先搜索（BFS）:

    • 类似于树的层序遍历，逐层探索图中的顶点。
    • 实现: 使用队列。
    • 时间复杂度: O(V + E)。

最短路径算法

  • Dijkstra算法:

    • 解决单源最短路径问题，即从一个顶点到所有其他顶点的最短路径。
    • 特点: 适用于边权重非负的图。
    • 实现步骤:
      1. 初始化源点的距离为 0，其他顶点的距离为无穷大。
      2. 使用优先队列选择当前距离最小的顶点。
      3. 更新该顶点相邻顶点的最短距离。
      4. 重复直到所有顶点都被处理。
    • 时间复杂度: O(V^2)，使用优先队列优化可降至 O(E + V log V)。

  • Bellman-Ford算法:

    • 解决单源最短路径问题，允许边权重为负。
    • 特点: 可以检测负权重环。
    • 实现步骤:
      1. 初始化源点的距离为 0，其他顶点的距离为无穷大。
      2. 进行 V-1 轮松弛操作，更新所有边的最短路径。
      3. 第 V 轮检查是否存在负权重环。
    • 时间复杂度: O(VE)。

最小生成树（MST）算法

  • Kruskal算法:

    • 寻找加权无向图的最小生成树。
    • 特点: 基于贪心策略，每次选择权重最小的边，直到构建出最小生成树。
    • 实现步骤:
      1. 将图中的边按权重从小到大排序。
      2. 初始化一个空树，并逐一检查排序后的边，若加入边不会形成环，则将其加入生成树。
      3. 重复直到树中包含所有顶点。
    • 时间复杂度: O(E log E)。

  • Prim算法:

    • 寻找加权无向图的最小生成树。
    • 特点: 也是基于贪心策略，从任意顶点出发，每次选择权重最小的连接新顶点的边。
    • 实现步骤:
      1. 从任意顶点开始，将其加入生成树。
      2. 在所有连接生成树的边中选择权重最小的边，并将对应顶点加入生成树。
      3. 重复直到生成树包含所有顶点。
    • 时间复杂度: O(V^2)，使用优先队列优化可降至 O(E + V log V)。

实践

  1. 图的基本操作和遍历算法:

    • 实现图的邻接矩阵和邻接表表示方法。
    • 编写DFS和BFS的实现代码，测试图的遍历效果。

  2. 最短路径问题:

    • 实现Dijkstra算法，使用该算法求解实际问题，如计算城市间的最短路径。
    • 理解Bellman-Ford算法，并使用其处理可能存在负权重的路径问题。

  3. 最小生成树:

    • 使用Kruskal和Prim算法实现最小生成树，应用于网络设计、基础设施规划等实际场景中。

实践代码

1. 图的基本操作和遍历算法
邻接矩阵和邻接表的表示

邻接矩阵表示:

class GraphMatrix {
    private int[][] adjMatrix;
    private int numVertices;

    public GraphMatrix(int numVertices) {
        this.numVertices = numVertices;
        adjMatrix = new int[numVertices][numVertices];
    }

    public void addEdge(int src, int dest) {
        adjMatrix[src][dest] = 1;
        adjMatrix[dest][src] = 1;  // 如果是有向图，这一行可以去掉
    }

    public void printMatrix() {
        for (int i = 0; i < numVertices; i++) {
            for (int j = 0; j < numVertices; j++) {
                System.out.print(adjMatrix[i][j] + " ");
            }
            System.out.println();
        }
    }
}

邻接表表示:

import java.util.LinkedList;

class GraphList {
    private LinkedList<Integer>[] adjList;
    private int numVertices;

    public GraphList(int numVertices) {
        this.numVertices = numVertices;
        adjList = new LinkedList[numVertices];
        for (int i = 0; i < numVertices; i++) {
            adjList[i] = new LinkedList<>();
        }
    }

    public void addEdge(int src, int dest) {
        adjList[src].add(dest);
        adjList[dest].add(src);  // 如果是有向图，这一行可以去掉
    }

    public void printList() {
        for (int i = 0; i < numVertices; i++) {
            System.out.print("Vertex " + i + ":");
            for (Integer node : adjList[i]) {
                System.out.print(" -> " + node);
            }
            System.out.println();
        }
    }
}
DFS 和 BFS 的实现

DFS 实现:

import java.util.*;

class DFS {
    private boolean[] visited;

    public DFS(int numVertices) {
        visited = new boolean[numVertices];
    }

    public void dfs(int vertex, LinkedList<Integer>[] adjList) {
        visited[vertex] = true;
        System.out.print(vertex + " ");

        for (int adjVertex : adjList[vertex]) {
            if (!visited[adjVertex]) {
                dfs(adjVertex, adjList);
            }
        }
    }
}

BFS 实现:

import java.util.*;

class BFS {
    private boolean[] visited;

    public BFS(int numVertices) {
        visited = new boolean[numVertices];
    }

    public void bfs(int startVertex, LinkedList<Integer>[] adjList) {
        Queue<Integer> queue = new LinkedList<>();
        visited[startVertex] = true;
        queue.add(startVertex);

        while (!queue.isEmpty()) {
            int vertex = queue.poll();
            System.out.print(vertex + " ");

            for (int adjVertex : adjList[vertex]) {
                if (!visited[adjVertex]) {
                    visited[adjVertex] = true;
                    queue.add(adjVertex);
                }
            }
        }
    }
}
测试图的遍历效果
public class Main {
    public static void main(String[] args) {
        // 使用邻接表表示图
        GraphList graph = new GraphList(5);
        graph.addEdge(0, 1);
        graph.addEdge(0, 2);
        graph.addEdge(1, 3);
        graph.addEdge(1, 4);
        graph.addEdge(2, 4);

        System.out.println("邻接表表示:");
        graph.printList();

        DFS dfsTraversal = new DFS(5);
        System.out.print("\nDFS Traversal: ");
        dfsTraversal.dfs(0, graph.adjList);

        BFS bfsTraversal = new BFS(5);
        System.out.print("\nBFS Traversal: ");
        bfsTraversal.bfs(0, graph.adjList);
    }
}
2. 最短路径算法
Dijkstra算法实现
import java.util.*;

class Dijkstra {
    private int[] dist;
    private boolean[] visited;
    private int numVertices;

    public Dijkstra(int numVertices) {
        this.numVertices = numVertices;
        dist = new int[numVertices];
        visited = new boolean[numVertices];
        Arrays.fill(dist, Integer.MAX_VALUE);
    }

    public void dijkstra(int[][] graph, int startVertex) {
        dist[startVertex] = 0;

        for (int i = 0; i < numVertices; i++) {
            int u = selectMinVertex();
            visited[u] = true;

            for (int v = 0; v < numVertices; v++) {
                if (!visited[v] && graph[u][v] != 0 && dist[u] != Integer.MAX_VALUE
                    && dist[u] + graph[u][v] < dist[v]) {
                    dist[v] = dist[u] + graph[u][v];
                }
            }
        }

        printSolution();
    }

    private int selectMinVertex() {
        int minDist = Integer.MAX_VALUE;
        int vertex = -1;

        for (int i = 0; i < numVertices; i++) {
            if (!visited[i] && dist[i] < minDist) {
                minDist = dist[i];
                vertex = i;
            }
        }

        return vertex;
    }

    private void printSolution() {
        System.out.println("Vertex\tDistance from Source");
        for (int i = 0; i < numVertices; i++) {
            System.out.println(i + "\t\t" + dist[i]);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        int[][] graph = {
            {0, 10, 0, 5, 0},
            {0, 0, 1, 2, 0},
            {0, 0, 0, 0, 4},
            {0, 3, 9, 0, 2},
            {7, 0, 6, 0, 0}
        };

        Dijkstra dijkstra = new Dijkstra(5);
        dijkstra.dijkstra(graph, 0); // 从顶点0开始
    }
}
Bellman-Ford算法实现
class BellmanFord {
    private int[] dist;
    private int numVertices;

    public BellmanFord(int numVertices) {
        this.numVertices = numVertices;
        dist = new int[numVertices];
        Arrays.fill(dist, Integer.MAX_VALUE);
    }

    public void bellmanFord(int[][] edges, int startVertex) {
        dist[startVertex] = 0;

        for (int i = 0; i < numVertices - 1; i++) {
            for (int[] edge : edges) {
                int u = edge[0];
                int v = edge[1];
                int weight = edge[2];

                if (dist[u] != Integer.MAX_VALUE && dist[u] + weight < dist[v]) {
                    dist[v] = dist[u] + weight;
                }
            }
        }

        for (int[] edge : edges) {
            int u = edge[0];
            int v = edge[1];
            int weight = edge[2];

            if (dist[u] != Integer.MAX_VALUE && dist[u] + weight < dist[v]) {
                System.out.println("图中包含负权重环");
                return;
            }
        }

        printSolution();
    }

    private void printSolution() {
        System.out.println("Vertex\tDistance from Source");
        for (int i = 0; i < numVertices; i++) {
            System.out.println(i + "\t\t" + dist[i]);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        int[][] edges = {
            {0, 1, -1}, {0, 2, 4},
            {1, 2, 3}, {1, 3, 2},
            {1, 4, 2}, {3, 2, 5},
            {3, 1, 1}, {4, 3, -3}
        };

        BellmanFord bellmanFord = new BellmanFord(5);
        bellmanFord.bellmanFord(edges, 0); // 从顶点0开始
    }
}
3. 最小生成树
Kruskal算法实现
import java.util.*;

class Edge implements Comparable<Edge> {
    int src, dest, weight;

    public Edge(int src, int dest, int weight) {
        this.src = src;
        this.dest = dest;
        this.weight = weight;
    }

    @Override
    public int compareTo(Edge other) {
        return this.weight - other.weight;
    }
}

class Kruskal {
    private int[] parent;
    private int numVertices;

    public Kruskal(int numVertices) {
        this.numVertices = numVertices;
        parent = new int[numVertices];
        for (int i = 0; i < numVertices; i++) {
            parent[i] = i;
        }
    }

    public void kruskal(List<Edge> edges) {
        Collections.sort(edges);

        List<Edge> mst = new ArrayList<>();
        for (Edge edge : edges) {
            int srcParent = find(edge.src);
            int destParent = find(edge.dest);

            if (srcParent

 != destParent) {
                mst.add(edge);
                parent[srcParent] = destParent;
            }
        }

        printSolution(mst);
    }

    private int find(int vertex) {
        if (parent[vertex] != vertex) {
            parent[vertex] = find(parent[vertex]);
        }
        return parent[vertex];
    }

    private void printSolution(List<Edge> mst) {
        System.out.println("Edge\tWeight");
        for (Edge edge : mst) {
            System.out.println(edge.src + " - " + edge.dest + "\t" + edge.weight);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        List<Edge> edges = new ArrayList<>();
        edges.add(new Edge(0, 1, 10));
        edges.add(new Edge(0, 2, 6));
        edges.add(new Edge(0, 3, 5));
        edges.add(new Edge(1, 3, 15));
        edges.add(new Edge(2, 3, 4));

        Kruskal kruskal = new Kruskal(4);
        kruskal.kruskal(edges);
    }
}
Prim算法实现
import java.util.*;

class Prim {
    private int[] key;
    private boolean[] mstSet;
    private int[] parent;
    private int numVertices;

    public Prim(int numVertices) {
        this.numVertices = numVertices;
        key = new int[numVertices];
        mstSet = new boolean[numVertices];
        parent = new int[numVertices];
        Arrays.fill(key, Integer.MAX_VALUE);
        Arrays.fill(parent, -1);
    }

    public void prim(int[][] graph) {
        key[0] = 0;
        parent[0] = -1;

        for (int count = 0; count < numVertices - 1; count++) {
            int u = selectMinKeyVertex();
            mstSet[u] = true;

            for (int v = 0; v < numVertices; v++) {
                if (graph[u][v] != 0 && !mstSet[v] && graph[u][v] < key[v]) {
                    parent[v] = u;
                    key[v] = graph[u][v];
                }
            }
        }

        printSolution();
    }

    private int selectMinKeyVertex() {
        int minKey = Integer.MAX_VALUE;
        int vertex = -1;

        for (int v = 0; v < numVertices; v++) {
            if (!mstSet[v] && key[v] < minKey) {
                minKey = key[v];
                vertex = v;
            }
        }

        return vertex;
    }

    private void printSolution() {
        System.out.println("Edge\tWeight");
        for (int i = 1; i < numVertices; i++) {
            System.out.println(parent[i] + " - " + i + "\t" + key[i]);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        int[][] graph = {
            {0, 2, 0, 6, 0},
            {2, 0, 3, 8, 5},
            {0, 3, 0, 0, 7},
            {6, 8, 0, 0, 9},
            {0, 5, 7, 9, 0}
        };

        Prim prim = new Prim(5);
        prim.prim(graph);
    }
}

总结

以上Java代码分别实现了图的邻接矩阵和邻接表表示、DFS和BFS遍历算法、Dijkstra和Bellman-Ford最短路径算法，以及Kruskal和Prim最小生成树算法。

君と僕903
关注
  • 23
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
《数据结构与算法之美》的学习笔记和python代码实现.zip
01-01
《数据结构与算法之美》是一本深入浅出介绍这些概念的书籍，而学习笔记和Python代码实现则是对该书内容的实践补充，帮助读者更直观地理解并应用所学。 1. 数据结构概述： 数据结构是组织、管理、存储和检索数据的...
算法数据结构学习笔记-C语言.zip
01-01
以上内容是数据结构学习笔记的主要内容，通过深入学习和实践，不仅可以提升编程技能，还能为解决实际问题提供理论基础。在C语言中实现这些数据结构，能够更好地理解其工作原理，从而在实际项目中灵活运用。
《数据结构与算法》笔记（1）
lilacs_的博客
01-16 1045
这是根据b站上青岛大学王卓老师的数据结构课整理的基于C语言的学习笔记
数据结构与算法学习笔记
tanqing24520的博客
09-12 3330
1. 数据结构与算法 1.1 知识脑图 1.2 什么是 数据结构 与 算法 数据结构 就是一组数据的存储结构 算法 就是操作一组数据的方法 数据结构是为算法服务的，算法要作用在特定的数据结构之上 1.3 为什么需要数据结构和算法 在计算机科学和互联网迅猛发展下，需要计算的数据量越来越庞大。但是计算机的计算能力是有限的，这么大量的数据计算，需要越来越多的计算机，需要越来越长的计算时间，注重效率的我们需要尽可能的提高计算效率 选用合适的数据结构和算法，特别是在处理体量非常庞大的数据的时候，可以极
数据结构—笔记整理—初识数据结构
热门推荐
好好读书
10-22 4万+
数据结构笔记及相关知识整理，冲冲冲！！！
黑马Java版数据结构学习笔记（一）
qq_46373615的博客
09-09 746
一、为什么要学习数据结构？ 1.数据结构包括数据对象集以及它们在计算机中的组织方式，即它们的逻辑和物理存储结构，一般我们可以认为数据结构指的是一组数据的存储结构。 2.算法就是操作数据的方法，即如何操作数据的效率更高，更节省资源。 3.所谓线性表，就是将数据排成一条长线一样的结构，数组，链，栈，队列都是线性表结构，线性表上的每个数据最多只能前后两个方向。 二、数组 2.1 定义 数组是一种线性表的数据...
王道2023数据结构笔记
一顿吃不饱的博客
07-15 1万+
线性表的定义​线性表是具有相同数据类型的n（n≥0）个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，则其一般表示为L=(a1,a2,…,ai,ai+1,…,an)​ai是线性表中的“第i个”元素线性表中的位序​a1是表头元素；an是表尾元素​除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继线性表的基本操作初始化表。构造一个空的线性表L，分配内存空间。销毁操作。插入操作。删除操作。...
数据结构（C语言描述）学习笔记.zip
01-01
这些知识点在“数据结构（C语言描述）学习笔记”中应该会详细阐述，包括它们的概念、实现方式、优缺点以及在实际问题中的应用。通过深入学习和实践，可以提升编程能力，更好地理解和解决复杂问题。
C、C++、Qt、Linux、ARM、数据结构等学习笔记.zip
06-16
在本压缩包“C、C++、Qt、Linux、ARM、数据结构等学习笔记.zip”中，包含了多种编程语言及重要计算机科学领域的学习资源，尤其是针对数据结构这一核心概念的深入探讨。数据结构是计算机科学的基础，对于理解和解决...
数据结构与算法系列笔记.zip
06-16
7. **高级数据结构**：如哈希表、Trie树、B树、B+树等，这些数据结构在数据库、搜索引擎等领域有广泛应用。 在"my_resource"文件夹中，你可能会找到关于这些主题的详细笔记、示例代码、练习题和解题思路，这对于...
数据结构之单向、双线链表
2301_78503818的博客
08-28 498
首先我们先定义链表节点的类型，以及里面包含的数据和存储下一个节点地址的指针，然后通过定义变量，使用malloc函数来申请一个头结点的空间，而后进行赋值操作即可完成对头结点的创建。链表大体可以分成有头链表（有头节点）和无头链表，今天主要记录一下单向链表和双线链表的一些基本操作。3.单向链表的遍历，寻找，删除，更改。6.链表的复杂操作（读者可酌情观看）链表空间的释放（链表的销毁）2.头插法插入链表节点。
数据结构-时间、空间复杂度-详解
2401_86587256的博客
08-23 1231
数据结构-时间、空间复杂度-详解
浅谈【数据结构】树与二叉树之哈夫曼树
weixin_67526434的博客
08-26 633
浅谈【数据结构】树与二叉树之哈夫曼树
【Java & 数据结构】HashMap和HashSet介绍
qq_42150700的博客
08-29 506
Map 和 Set 是 Java 集合框架中的两个接口, 其分别对应着两种不同的搜索模型. 其中 一个是纯 key 模型, 另一个则是 key-value 模型.纯 key 模型就类似于一个集合, 里面装载着一些元素, 这些元素只包含其本身. 例如我有一个冰箱, 里面装着各式各样的饮料, 那么此时这个冰箱就可以看作是一个饮料的集合, 里面装载着饮料. 此时如果我要在里面找饮料, 找的就是饮料本身.
【数据结构】-----哈希
m0_73470633的博客
08-29 465
一文看懂哈希结构！
数据结构（邓俊辉）学习笔记】串 05——KMP算法：理解next[]表
weixin_44399845的博客
08-26 1031
KMP算法：理解next[]表
Redis八种数据结构简介
最新发布
m0_67496588的博客
08-29 599
Redis八种数据结构
【数据结构-二维前缀和】【含空间优化】力扣3070. 元素和小于等于 k 的子矩阵的数目
sjsjs11的博客
08-29 146
col_sum[j]在遍历行的时候，也会依次计算该列的元素和，要计算前缀和s，实际上就是目前该列的元素和逐列累加，当发现s大于k的时候，那么就停止该行接下来的前缀和，继续计算下一行第一列开始的前缀和，继续遍历行的某个位置的前缀和。这种方法就是传统的前缀和做法，在这道题中，如果group[i][j]小于k，则继续遍历，然后count增加，如果group[i][j]大于k，说明不需要继续遍历这一行接下来列的前缀和了，直接开始计算新一行每一列的前缀和。返回包含 grid 左上角元素、元素和小于或等于 k 的。
数据结构-线性表
zhoupenghui168的博客
08-29 583
好了,线性表相关数据结构就基本上差不多了, 从上面可知,线性表分为顺序表,链表(单向,双向),栈,队列等,他们存储的是单值情况,那么如果要存储多值情况,如:key-value情况,怎么办呢,这里就需要使用符号表了
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值