无向图-邻接表方式

【理论知识可以参考这边】

图论算法——无向图的邻接链表实现_日积月累，天道酬勤-CSDN博客_无向图的邻接链表

图论算法——无向图的深度优先搜索和广度优先搜索_日积月累，天道酬勤-CSDN博客

漫画：图的 “最短路径” 问题_程序员小灰的博客-CSDN博客

 

【lua实现】

local Graph = {}
Graph.__index = Graph

---无向图
function Graph.new()
    local obj = {}
    setmetatable(obj, Graph)

    obj:ctor()
    return obj
end

function Graph:ctor()
    self.adjacent = {}
    self.edgeCount = 0
    self.vertexList = {}
end

function Graph:GetVertexCount()
    return #self.vertexList
end

function Graph:GetVertex(index)
    return self.vertexList[index]
end

function Graph:GetEdgeCount()
    return self.edgeCount
end

function Graph:AddVertex(v)
    local list = self.adjacent[v]
    if nil == list then
        list = {}
        self.adjacent[v] = list
        table.insert(self.vertexList, v)
    else
        --顶点已存在
    end
end

function Graph:AddEdge(v1, v2)
    local list1 = self.adjacent[v1]
    local list2 = self.adjacent[v2]
    if nil == list1 or nil == list2 then
        return --顶点不存在
    end

    table.insert(list1, v2) --最好判断下在list中是否已存在
    table.insert(list2, v1)
    self.edgeCount = self.edgeCount + 1
end

function Graph:GetAdjacent(v)
    return self.adjacent[v]
end

function Graph:__tostring()
    print("-----Graph")
    for i=1,#self.vertexList do
        local v = self.vertexList[i]
        local adjList = self.adjacent[v]
        print(v, "-->", table.concat(adjList, ", "))
    end
    print("-----")
end

return Graph

 

测试代码：

function CreateGraph()
    local g = Graph.new()
    g:AddVertex("A")
    g:AddVertex("B")
    g:AddVertex("C")
    g:AddVertex("D")
    g:AddVertex("E")
    g:AddVertex("F")
    g:AddVertex("G")

    g:AddEdge("A", "B")
    g:AddEdge("A", "C")
    g:AddEdge("B", "D")
    g:AddEdge("B", "E")
    g:AddEdge("C", "D")
    g:AddEdge("C", "F")
    g:AddEdge("D", "E")
    g:AddEdge("D", "F")
    g:AddEdge("E", "G")
    g:AddEdge("F", "G")

    print("v ct: ", g:GetVertexCount())
    print("edge ct:", g:GetEdgeCount())
    tostring(g)
    return g
end

上面的代码会创建出这样一张图

 

 

 

 

【深度优先搜索】

# 这边使用了递归来实现

# 用途：会把某个点的所有可达顶点都走一遍，即可以通过它来确定两个点之间是否可达

function TestDfs1()
    local visited = {}

    function Dfs1(g, vertex)
        print(vertex)

        visited[vertex] = true
        local list = g:GetAdjacent(vertex)
        for i=1,#list do
            local adjV = list[i]
            if not visited[adjV] then
                Dfs1(g, adjV)
            end
        end
    end

    local g = CreateGraph()
    Dfs1(g, "A")
end
TestDfs1()

 

【广度优先搜索】

# 一般会借助一个队列来实现

# 用途1：会把某个点的所有可达顶点都走一遍，即可以知道两个点之间是否可达

# 用途2：可以算出点A到点B的最短路径 

function TestBfs1()
    local edgeFrom = {}

    function Bfs1(g, vertex)
        local visited = {}
        local queue = {}
        visited[vertex] = true --加入queue就要设为visited
        table.insert(queue, vertex)

        while #queue > 0 do
            local v = queue[1]
            print("---", table.concat(queue, ", "))
            print(v)
            table.remove(queue, 1)

            local list = g:GetAdjacent(v)
            for i=1,#list do
                local adjV = list[i]
                if not visited[adjV] then
                    visited[adjV] = true --加入queue就要设为visited
                    edgeFrom[adjV] = v
                    table.insert(queue, adjV)
                end
            end
        end
    end

    local g = CreateGraph()
    Bfs1(g, "A")

    local path = {}
    local target = "G"
    local start = "A"
    local v = target
    while v ~= start do
        table.insert(path, v)
        v = edgeFrom[v]
    end
    table.insert(path, v)
    print("shortest path: ", table.concat(path))
end
TestBfs1()