Graphs, Networks, and Discrete Structure

Last Updated May 30, 2026

Graphs are one of the most powerful structures in discrete mathematics. A graph turns objects into vertices and relationships into edges. With that simple act, mathematics gains a language for studying connection, path, dependency, flow, hierarchy, clustering, reachability, centrality, vulnerability, and structure. Graphs make relationships visible without requiring the objects themselves to be numerical.

Networks are graphs interpreted in context. A transportation network connects places. A communication network connects devices. A social network connects people or institutions. A citation network connects texts. A biological network connects genes, proteins, species, or ecological interactions. A knowledge graph connects concepts. A dependency graph connects tasks, proofs, software modules, or infrastructure systems. In each case, graph theory provides a discrete mathematical structure for analyzing how parts relate to one another.

This article examines graphs, networks, and discrete structure as a foundational mode of mathematical thinking. It explores vertices, edges, adjacency, degree, paths, cycles, connectivity, trees, directed graphs, weighted graphs, bipartite graphs, graph representations, traversal algorithms, shortest paths, network centrality, graph modeling, Haskell-style typed graph structures, SQL schemas, and the responsible interpretation of networked systems in computation, artificial intelligence, institutions, science, infrastructure, and public decision-making.

What Graphs Mean

A graph is a mathematical structure made of vertices and edges. Vertices represent objects. Edges represent relationships between objects. This definition is intentionally abstract. The vertices might be people, cities, concepts, web pages, genes, tasks, servers, mathematical statements, or data records. The edges might represent friendship, roads, similarity, dependency, citation, communication, influence, flow, or adjacency.

This abstraction is the source of graph theory’s power. Many systems that look different in the world share the same mathematical form: objects connected by relationships. Once a system is represented as a graph, mathematics can ask structural questions. Are all vertices connected? Which vertices are central? Are there cycles? What is the shortest path? Which edges are bridges? Can the graph be colored? Does it contain a matching? Which nodes are reachable from which others?

A graph is therefore not a picture. A graph may be drawn, but the drawing is only a representation. The mathematical object is the set of vertices and the set of edges. Two drawings can look different while representing the same graph. Conversely, two drawings can look similar while representing different structures. This distinction is essential for serious graph thinking.

Back to top ↑

Graphs as Discrete Structure

Graphs belong to discrete mathematics because they are built from distinct elements and relationships. A graph does not require a continuum. It does not require smooth change. It studies structure through separated units: vertex, edge, path, component, cycle, tree, cut, matching, coloring, and network position.

This discrete structure makes graphs especially useful in computation. Computers store finite objects and relationships. Databases store records. Programs manipulate nodes and links. Search engines index pages and links. Knowledge graphs connect entities. Software dependency systems connect modules. Social platforms represent accounts and interactions. Graph theory gives mathematical discipline to these structures.

Graphs also reveal why discrete structure can be complex. A graph with a small number of vertices may have many possible edge patterns. A graph with many vertices can have enormous structural variety. Local connections can create global properties that are not obvious from individual nodes alone.

Graph thinking therefore turns discrete relationships into mathematical objects. It allows structure to be counted, searched, proven, visualized, stored, computed, and interpreted.

Back to top ↑

Vertices, Edges, and Adjacency

The basic vocabulary of graph theory begins with vertices and edges. Two vertices are adjacent if they are connected by an edge. An edge is incident to the vertices it connects. In an undirected graph, an edge has no orientation: \(u\) connected to \(v\) is the same as \(v\) connected to \(u\). In a directed graph, an edge has direction: \(u\to v\) is not the same as \(v\to u\).

Adjacency is the smallest unit of graph structure. A graph’s global properties emerge from many local adjacency relationships. Knowing who is adjacent to whom allows one to compute degree, paths, connected components, cycles, cliques, cuts, and traversal order.

The choice of graph convention matters. Are loops allowed? Are multiple edges allowed between the same vertices? Are edges directed? Are they weighted? Are vertices labeled? The answers determine what mathematical claims are valid.

Back to top ↑

Degree, Neighborhoods, and Local Structure

The degree of a vertex is the number of edges incident to it. In a simple undirected graph, degree counts how many neighbors a vertex has. In a directed graph, one distinguishes in-degree and out-degree: in-degree counts incoming edges, while out-degree counts outgoing edges.

Degree is a local measure, but local degree patterns can reveal global structure. A graph where every vertex has the same degree is regular. A graph with a few very high-degree vertices and many low-degree vertices may have hub-like structure. A vertex with degree zero is isolated. A vertex with degree one is a leaf in a tree-like structure.

The handshaking lemma is one of the first major results about degree. It states that the sum of all vertex degrees in an undirected graph equals twice the number of edges, because every edge contributes one degree to each of its two endpoints.

This result shows how local and global structure connect. Degree is local; edge count is global. Graph theory often works by linking these scales.

Back to top ↑

Paths, Walks, Cycles, and Reachability

A walk is a sequence of vertices in which consecutive vertices are connected by edges. A path is often understood as a walk with no repeated vertices. A cycle is a path that returns to its starting vertex. These concepts allow graph theory to reason about movement, dependency, influence, access, feedback, and recurrence.

Reachability asks whether one vertex can be reached from another by following edges. In undirected graphs, reachability is symmetric. In directed graphs, reachability may be asymmetric: \(u\) may reach \(v\) even if \(v\) cannot reach \(u\). Reachability is fundamental in routing, dependency analysis, proof graphs, state machines, workflows, software systems, and knowledge networks.

Paths make graph structure dynamic. Edges define possible steps; paths define possible journeys. A graph is not only a set of connections. It is a space of possible movement through relation.

Back to top ↑

Connectivity and Components

A graph is connected if every vertex can be reached from every other vertex by a path. If a graph is not connected, it breaks into connected components: maximal subgraphs in which vertices are mutually reachable. Connectivity is one of the most important global graph properties.

Connectivity matters in infrastructure, communication, ecology, logistics, software, knowledge systems, and institutions. A disconnected transportation network prevents travel between regions. A disconnected communication network isolates devices. A disconnected knowledge graph may prevent concepts from being retrieved or related. A disconnected organization may have units that cannot coordinate effectively.

Connectivity shows how global structure can depend on a small number of local relationships. A single bridge edge may hold a network together. A single hub may connect otherwise separate communities. This is why graph thinking is essential for resilience analysis.

Back to top ↑

Trees, Acyclic Structure, and Hierarchy

A tree is a connected graph with no cycles. Trees are central because they represent minimal connectivity: all vertices are connected, but there is no redundant cycle. Removing any edge from a tree disconnects it. Adding any new edge creates a cycle.

Trees appear in hierarchies, taxonomies, file systems, proof dependencies, parse trees, decision trees, evolutionary trees, organizational charts, and spanning structures. A rooted tree selects one vertex as the root and organizes other vertices by parent-child relationships. This makes trees especially useful for representing nested and recursive structure.

Trees are useful because they simplify relation into hierarchy. But not all systems are tree-like. Many real networks contain cycles, cross-links, feedback, shared dependencies, and overlapping communities. A tree can clarify hierarchy, but it can also oversimplify systems whose structure is genuinely networked.

Back to top ↑

Directed Graphs and Asymmetric Relations

A directed graph, or digraph, has edges with direction. A directed edge \(u\to v\) indicates a relationship from \(u\) to \(v\). Direction is essential when relationships are asymmetric: one page links to another, one task depends on another, one person follows another, one theorem uses a lemma, one state transitions to another, or one process sends output to another.

Directed graphs support concepts such as in-degree, out-degree, reachability, strongly connected components, topological ordering, dependency analysis, and directed cycles. A directed acyclic graph, or DAG, has no directed cycles. DAGs are central in scheduling, compilation, causal modeling, version control, workflows, proof dependencies, and data pipelines.

Direction changes interpretation. In an undirected social relation, connection may be mutual. In a directed citation network, citation flows one way. In a dependency graph, direction determines what must come first. Graph modeling must therefore state clearly whether relationships are symmetric or directional.

Back to top ↑

Weighted Graphs, Distance, and Cost

A weighted graph assigns a value, or weight, to each edge. The weight may represent distance, cost, time, strength, capacity, probability, risk, similarity, or resistance. Weighted graphs allow graph theory to model not only whether a connection exists, but how significant that connection is.

Weighted graphs support shortest-path problems, minimum spanning trees, flow networks, optimization, similarity graphs, transportation routing, infrastructure planning, and machine learning. But weights require interpretation. A low weight might mean short distance, low cost, high similarity, or high priority depending on the model. The meaning must be specified.

Weighted graph thinking requires both mathematical and interpretive discipline. A shortest path is only meaningful relative to the chosen weight. Minimizing distance is not the same as minimizing time, cost, risk, or harm.

Back to top ↑

Bipartite Graphs, Matching, and Assignment

A bipartite graph has vertices divided into two sets, with edges only between the sets and not within them. Bipartite graphs are natural for modeling assignment, matching, affiliation, membership, recommendation, and two-mode relationships.

Examples include workers and tasks, students and courses, authors and papers, users and products, genes and diseases, committees and members, or sensors and monitored locations. A matching selects edges so that no vertex is used more than once. Matching theory is central to assignment problems, resource allocation, market design, scheduling, and optimization.

Bipartite graphs show that graph theory can represent more than direct similarity. Sometimes the most important structure is affiliation between different kinds of objects. This is especially important in data systems, social science, biology, economics, and institutional analysis.

Back to top ↑

Adjacency Lists, Matrices, and Graph Representation

A graph can be represented in several ways. The representation affects storage, computation, interpretation, and algorithmic efficiency. Two common representations are adjacency lists and adjacency matrices.

An adjacency list stores, for each vertex, a list of neighboring vertices. This is efficient for sparse graphs, where the number of edges is small relative to the number of possible edges. An adjacency matrix stores a square matrix in which entry \(A_{ij}\) records whether an edge exists from vertex \(i\) to vertex \(j\). This is useful for dense graphs and for algebraic graph methods.

Graph representation is not only a technical detail. It shapes what questions are easy to ask. A graph stored as a database table invites query and audit. A graph stored as a matrix invites algebra. A graph stored as adjacency lists invites traversal.

Back to top ↑

Graph Algorithms and Traversal

Graph algorithms make graph structure executable. Breadth-first search explores a graph layer by layer. Depth-first search explores as far as possible along a branch before backtracking. Dijkstra’s algorithm finds shortest paths in weighted graphs with nonnegative edge weights. Topological sorting orders vertices in a directed acyclic graph so dependencies come before dependents.

These algorithms are not merely programming tools. They express mathematical ideas: reachability, distance, dependency, order, component structure, and optimization. Each algorithm depends on assumptions about the graph.

Graph algorithms require careful handling of edge cases. A graph may be disconnected. A directed graph may contain cycles. A weighted graph may have negative edges. A traversal may repeat vertices unless visited states are tracked. The algorithm must match the graph structure.

Back to top ↑

Networks as Interpreted Graphs

A network is a graph with meaning. The mathematics may define vertices and edges, but the interpretation defines what those vertices and edges represent. This distinction matters. A graph can be structurally valid while its interpretation is weak, biased, incomplete, or misleading.

For example, a social network graph may connect two people because they exchanged messages, followed each other, appeared in the same database, or were inferred to be similar. These edge meanings are not interchangeable. A transportation network edge may mean a road exists, but not necessarily that it is safe, affordable, accessible, or open. A knowledge graph edge may encode a relationship, but that relationship may need provenance, confidence, and context.

Network analysis is strongest when graph structure and domain meaning are both explicit. Mathematics can analyze the structure, but interpretation requires evidence, context, and accountability.

Back to top ↑

Centrality, Influence, and Structural Position

Centrality measures try to describe the structural importance of vertices in a network. Degree centrality counts direct connections. Closeness centrality measures how near a vertex is to others. Betweenness centrality measures how often a vertex lies on shortest paths between others. Eigenvector-style centralities reward connection to other important vertices.

Centrality is useful, but it must be interpreted carefully. A vertex can be central under one measure and not another. High degree does not automatically mean power. Betweenness may indicate brokerage, vulnerability, or burden. Centrality in a measured network may reflect data availability as much as actual importance.

Centrality measures are structural summaries, not moral judgments. They can help identify important positions in a graph, but they do not by themselves explain legitimacy, expertise, justice, responsibility, or lived significance.

Back to top ↑

Graph Modeling in Data Systems and AI

Graphs are central to modern data systems and artificial intelligence. Knowledge graphs represent entities and relationships. Recommendation systems use user-item graphs. Graph neural networks operate on node and edge structure. Search engines analyze links. Fraud detection systems inspect transaction networks. Supply-chain systems model dependencies. Scientific databases connect observations, models, instruments, concepts, and sources.

Graph modeling begins by deciding what counts as a node and what counts as an edge. This is not trivial. Should a person and an organization both be vertices? Should an event be a vertex or an edge? Should an edge represent observed interaction, inferred similarity, membership, causation, citation, co-occurrence, or dependency? Should edge confidence be stored? Should provenance be recorded?

Graph-based AI can be powerful because it uses relational structure. But graph-based inference can also spread error through the network. A false edge, biased node attribute, incomplete subgraph, or misleading centrality measure can affect downstream outputs. Graph models require provenance, validation, and interpretive restraint.

Back to top ↑

Proof and Graph-Theoretic Reasoning

Graph theory is rich in proof methods. Proofs may use degree counting, contradiction, induction, extremal arguments, invariants, coloring, matching, constructive algorithms, and structural decomposition. Graph proofs often show how local constraints force global consequences.

The handshaking lemma is a simple example: because every edge contributes two endpoints, the sum of degrees must be even. From this, it follows that the number of vertices of odd degree must be even. This is a purely structural result, independent of what the graph represents.

Graph proofs also show the relationship between construction and impossibility. Some proofs construct a path, coloring, matching, or spanning tree. Others show that a desired structure cannot exist under given constraints. This makes graph theory a strong training ground for mathematical reasoning.

Graph-theoretic proof teaches that structure has consequences. Once vertices and edges are defined, not everything is possible.

Back to top ↑

Learning Graph Thinking

Learning graph theory requires a shift from object-centered thinking to relation-centered thinking. Students often focus on the drawing rather than the structure. They may mistake visual distance for graph distance, layout position for centrality, or apparent clustering for a proven property. Graph thinking requires separating the mathematical graph from its visual representation.

Good graph learning uses multiple representations: edge lists, adjacency lists, adjacency matrices, diagrams, traversal tables, proof outlines, and code. Students should learn to move between them. A diagram helps intuition. An edge list clarifies data. A matrix enables algebra. An adjacency list supports algorithms. A proof shows what follows from definitions.

Graph thinking becomes mature when learners can ask both structural and interpretive questions: What is connected? What does connection mean? What follows mathematically? What should not be inferred?

Back to top ↑

A Mathematical Lens: Object, Relation, Path, Structure

A useful lens for graphs and networks is the sequence: object, relation, path, structure. First, identify the objects. Then define the relationships. Then study the paths created by those relationships. Finally, analyze the global structure that emerges.

This lens applies across graph theory. In a transportation network, objects are places, relations are routes, paths are journeys, and structure reveals accessibility or vulnerability. In a proof graph, objects are statements, relations are dependencies, paths are chains of justification, and structure reveals how the proof is organized. In a knowledge graph, objects are concepts, relations are semantic links, paths are conceptual routes, and structure reveals organization or gaps.

This framework helps keep graph thinking grounded. It reminds us that a graph is both a formal structure and, when used as a network model, an interpreted representation of something beyond the mathematics.

Back to top ↑

Computational Companion Examples

The companion repository for this article should extend the Mathematical Thinking codebase with examples focused on graph representations, adjacency lists, adjacency matrices, breadth-first search, depth-first search, connected components, directed graphs, topological sorting, weighted shortest paths, bipartite matching scaffolds, network centrality, Haskell algebraic data types, SQL graph schemas, and responsible interpretation of graph models. The examples below are compact article-level previews; the repository can expand them into richer professional workflows.

Python: Graph Traversal and Connected Components

from collections import deque
from typing import Dict, Set

Graph = Dict[str, Set[str]]

def breadth_first_component(graph: Graph, start: str) -> Set[str]:
    visited: Set[str] = set()
    queue: deque[str] = deque([start])

    while queue:
        node = queue.popleft()
        if node in visited:
            continue

        visited.add(node)

        for neighbor in sorted(graph.get(node, set())):
            if neighbor not in visited:
                queue.append(neighbor)

    return visited

def degree_table(graph: Graph) -> dict[str, int]:
    return {node: len(neighbors) for node, neighbors in graph.items()}

graph = {
    "A": {"B", "C"},
    "B": {"A", "D"},
    "C": {"A"},
    "D": {"B"},
    "E": set()
}

print("degree table:", degree_table(graph))
print("component from A:", breadth_first_component(graph, "A"))
print("component from E:", breadth_first_component(graph, "E"))

R: Adjacency Matrix and Degree Audit

vertices <- c("A", "B", "C", "D", "E")

edges <- data.frame(
  source = c("A", "A", "B"),
  target = c("B", "C", "D"),
  stringsAsFactors = FALSE
)

adjacency <- matrix(0, nrow = length(vertices), ncol = length(vertices))
rownames(adjacency) <- vertices
colnames(adjacency) <- vertices

for (i in seq_len(nrow(edges))) {
  s <- edges$source[i]
  t <- edges$target[i]
  adjacency[s, t] <- 1
  adjacency[t, s] <- 1
}

degree_audit <- data.frame(
  vertex = vertices,
  degree = rowSums(adjacency),
  interpretation = "degree counts local adjacency in an undirected graph"
)

print(adjacency)
print(degree_audit)

Julia: Weighted Shortest-Path Scaffold

function dijkstra(vertices, edges, source)
    dist = Dict(v => Inf for v in vertices)
    dist[source] = 0.0
    visited = Set{String}()

    while length(visited) < length(vertices)
        candidates = [v for v in vertices if !(v in visited)]
        isempty(candidates) && break

        u = candidates[argmin([dist[v] for v in candidates])]
        push!(visited, u)

        for (a, b, w) in edges
            if a == u && dist[u] + w < dist[b]
                dist[b] = dist[u] + w
            end
        end
    end

    return dist
end

vertices = ["A", "B", "C", "D"]
edges = [
    ("A", "B", 2.0),
    ("A", "C", 5.0),
    ("B", "D", 3.0),
    ("C", "D", 1.0)
]

println(dijkstra(vertices, edges, "A"))
println("Interpretation: shortest path depends on the meaning assigned to edge weights.")

Haskell: Graphs as Typed Discrete Structures

{-# OPTIONS_GHC -Wall #-}

data Vertex = A | B | C | D | E
  deriving (Eq, Ord, Show, Enum, Bounded)

data Edge = Edge Vertex Vertex
  deriving (Eq, Show)

type Graph = [Edge]

vertices :: [Vertex]
vertices = [minBound .. maxBound]

neighbors :: Vertex -> Graph -> [Vertex]
neighbors v edges =
  [ y | Edge x y <- edges, x == v ] ++
  [ x | Edge x y <- edges, y == v ]

degree :: Vertex -> Graph -> Int
degree v graph =
  length (neighbors v graph)

isAdjacent :: Vertex -> Vertex -> Graph -> Bool
isAdjacent u v graph =
  Edge u v `elem` graph || Edge v u `elem` graph

main :: IO ()
main = do
  let graph = [Edge A B, Edge A C, Edge B D]
  print [(v, degree v graph) | v <- vertices]
  print (neighbors A graph)
  print (isAdjacent A D graph)

SQL: Graph Metadata and Edge Schema

CREATE TABLE graph_node (
  node_id TEXT PRIMARY KEY,
  label TEXT NOT NULL,
  node_type TEXT NOT NULL,
  interpretation TEXT NOT NULL
);

CREATE TABLE graph_edge (
  edge_id TEXT PRIMARY KEY,
  source_node_id TEXT NOT NULL,
  target_node_id TEXT NOT NULL,
  graph_id TEXT NOT NULL,
  directed INTEGER NOT NULL,
  weight REAL,
  relation_type TEXT NOT NULL,
  evidence_note TEXT NOT NULL,
  interpretation TEXT NOT NULL,
  FOREIGN KEY (source_node_id) REFERENCES graph_node(node_id),
  FOREIGN KEY (target_node_id) REFERENCES graph_node(node_id)
);

CREATE TABLE graph_model_warning (
  warning_id TEXT PRIMARY KEY,
  graph_id TEXT NOT NULL,
  warning TEXT NOT NULL,
  mitigation TEXT NOT NULL
);

CREATE TABLE graph_algorithm_audit (
  algorithm_id TEXT PRIMARY KEY,
  graph_id TEXT NOT NULL,
  algorithm_name TEXT NOT NULL,
  assumption_note TEXT NOT NULL,
  output_interpretation TEXT NOT NULL
);

These examples treat graphs as executable discrete structures. Vertices and edges can be stored, traversed, queried, typed, weighted, audited, and interpreted. The purpose is not to replace mathematical proof or domain expertise, but to make graph structure explicit, reproducible, and inspectable.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-thinking workspace focused on graph representations, adjacency lists, adjacency matrices, graph traversal, connected components, directed graphs, weighted graphs, shortest paths, trees, bipartite structures, centrality, Haskell algebraic data types, SQL graph schemas, and responsible interpretation of networks.

Back to top ↑

Networks, Power, and Responsible Interpretation

Graphs and networks are powerful because they make relationships visible. But visibility is never neutral. What a network shows depends on what it treats as a node, what it treats as an edge, what data it includes, what data it excludes, what weights it assigns, and what interpretations it permits.

A network can reveal hidden dependency, but it can also create false association. A social graph can show interaction, but not necessarily trust, consent, intimacy, or influence. A centrality measure can identify structural position, but not moral worth, expertise, legitimacy, or lived burden. A risk network can show exposure, but it may also stigmatize communities if interpreted without context.

Responsible graph thinking asks: What are the nodes? What are the edges? Who defined them? What evidence supports each relation? What is missing? What does centrality actually measure? Who may be harmed if structural association is interpreted as proof?

Graphs can clarify connection, but they should not be used to hide uncertainty, power, or judgment behind visual complexity.

Back to top ↑

Why Graphs and Networks Matter

Graphs matter because they give mathematics a general language for relationship. They show how discrete objects become structured systems through connection. They reveal paths, components, cycles, bottlenecks, hierarchies, dependencies, clusters, and flows. They make it possible to reason about systems whose most important features are not isolated values, but relationships among parts.

Graphs also matter because modern life is networked. Infrastructure networks move water, energy, traffic, goods, and information. Digital networks connect devices, platforms, documents, and users. Scientific networks connect species, genes, proteins, citations, instruments, and datasets. Institutional networks connect rules, responsibilities, agencies, communities, and resources. AI systems increasingly use graph structures to organize knowledge, recommendations, dependencies, and inference.

Graph thinking trains the mind to ask precise relational questions. What is connected? What is disconnected? Which paths exist? Which nodes are central? Which edges are critical? Where are cycles? What assumptions define the network? What does connection mean? What should not be inferred?

Graphs, networks, and discrete structure are therefore not just technical topics. They are ways of understanding the architecture of relationship. They show how local connections create global form, how systems depend on paths and bottlenecks, and how mathematical structure can make hidden relationships visible—provided interpretation remains careful, grounded, and accountable.

Back to top ↑

Related Articles

• What Is Mathematical Thinking? Pattern, Proof, Architecture, and Reason
• Sets, Relations, and Functions as Modes of Thought
• Discrete Mathematics and the Logic of Structure
• Combinatorics and the Mathematics of Possibility
• Recursion and Recursive Thinking
• Logic and the Structure of Formal Inference
• Proof and the Logic of Mathematical Justification
• Patterns, Structure, and the Mathematical Imagination
• Mathematical Thinking for Computer Science
• Algorithms, Proof, and Formal Reasoning

Further Reading

• Barabási, A.-L. (2016) Network Science. Cambridge: Cambridge University Press. Available at: https://networksciencebook.com/
• Bondy, J.A. and Murty, U.S.R. (2008) Graph Theory. London: Springer. Available at: https://link.springer.com/book/10.1007/978-1-84628-970-5
• Diestel, R. (2017) Graph Theory. 5th edn. Berlin: Springer. Available at: https://diestel-graph-theory.com/
• Easley, D. and Kleinberg, J. (2010) Networks, Crowds, and Markets: Reasoning About a Highly Connected World. Cambridge: Cambridge University Press. Available at: https://www.cs.cornell.edu/home/kleinber/networks-book/
• Gross, J.L., Yellen, J. and Zhang, P. (2014) Handbook of Graph Theory. 2nd edn. Boca Raton: CRC Press.
• Newman, M.E.J. (2018) Networks. 2nd edn. Oxford: Oxford University Press. Available at: https://global.oup.com/academic/product/networks-9780198805090
• West, D.B. (2001) Introduction to Graph Theory. 2nd edn. Upper Saddle River, NJ: Prentice Hall.
• Wilson, R.J. (2010) Introduction to Graph Theory. 5th edn. Harlow: Pearson.

Back to top ↑

References

• Barabási, A.-L. (2016) Network Science. Cambridge: Cambridge University Press. Available at: https://networksciencebook.com/
• Bondy, J.A. and Murty, U.S.R. (2008) Graph Theory. London: Springer. Available at: https://link.springer.com/book/10.1007/978-1-84628-970-5
• Diestel, R. (2017) Graph Theory. 5th edn. Berlin: Springer. Available at: https://diestel-graph-theory.com/
• Easley, D. and Kleinberg, J. (2010) Networks, Crowds, and Markets: Reasoning About a Highly Connected World. Cambridge: Cambridge University Press. Available at: https://www.cs.cornell.edu/home/kleinber/networks-book/
• Gross, J.L., Yellen, J. and Zhang, P. (2014) Handbook of Graph Theory. 2nd edn. Boca Raton: CRC Press.
• Newman, M.E.J. (2018) Networks. 2nd edn. Oxford: Oxford University Press. Available at: https://global.oup.com/academic/product/networks-9780198805090
• West, D.B. (2001) Introduction to Graph Theory. 2nd edn. Upper Saddle River, NJ: Prentice Hall.
• Wilson, R.J. (2010) Introduction to Graph Theory. 5th edn. Harlow: Pearson.

Back to top ↑