Question

我正在研究我的scala印章并实现了一个小图Api来跟踪添加到图形中的顶点和边。我有基本的GraphLike Trait，并且有一个Undirected Graph类（UnDiGraph）和一个扩展DiGraph特征的Directed图类（GraphLike）。这是一些列表

trait GraphLike[T] {
    val vertices: Map[T, VertexLike[T]]
    def addEdge( a:T, b:T ): GraphLike[T]
    def addVertex( t:T ): GraphLike[T]
    def addVertex( vert: VertexLike[T] ): GraphLike[T]
    def adjacency( t:T ): Option[ List[T] ]  =
    {
      if ( vertices contains t )
        Some( vertices(t).adjList )
      else
        None
    }
    def vertNum: Integer = vertices size
    def edgeNum: Integer = 
    {
      def summer( sum: Integer, ms: Map[T, VertexLike[T] ] ): Integer =
      {
        if ( ms.isEmpty )
          sum
        else
          summer( sum + ms.head._2.adjList.size, ms.tail )
      }
      summer( 0, vertices )
    }
    def getVertex( t: T ): VertexLike[T] =
    {
      vertices( t )
    }
    def edgeExists( a:T, b:T ): Boolean =
    {
      try
      {
          if( vertices( a ).adjList contains b )
            true
          else
            false
      }catch {
        case ex: NoSuchElementException => false 
      }
    }
}

看看Directe图的样子。

class DiGraph[T](val vertices: Map[ T, VertexLike[ T ] ] = Map.empty ) extends GraphLike[T] {
    def makeVertex( t:T ): VertexLike[T] = new Vertex( t )

    def addEdge( a:T, b:T ): GraphLike[T] =
    {
      //Make sure vertices exist
      if( edgeExists(a, b) )
        this
      else {
        try {
          vertices(b)
          vertices(a)
        } catch {
          case ex: NoSuchElementException => println("Vertices not Found"); this
        }
        addVertex( vertices( a ) + b )
      }
    }
    def addVertex( t:T ): DiGraph[T] = 
    {
      if( vertices contains t ) this
      else
      new DiGraph[T]( vertices + ( t -> makeVertex(t) ) )
    }
    def addVertex( vert: VertexLike[T] ): DiGraph[T] =
    {
      new DiGraph[T]( vertices + ( vert.apply -> vert ) ) 
    }
}

顶点存储在从类型T到VertexLike [T]的Map中。 Vertex Like基本上包含特定Vertex的邻接列表。看看VertexLike的样子：

trait VertexLike[T] 
{
  def addEdgeTo( dest: T ): VertexLike[T]
  def adjList: List[T]
  def +( dest: T) = addEdgeTo(dest)
  def apply: T
} 

class Vertex[T](t: T, adj: List[T] = List() ) extends VertexLike[T]
{
    def apply() = t
    def adjList = adj
    def addEdgeTo( dest: T ) = 
      if( adjList contains dest )
        this
      else
        new Vertex[T]( t, dest :: adjList )
}

（是的......我意识到类中的apply方法是无用的，它只适用于对象。稍后实现）。

无论如何，我有一个示例图，其中我有大约80,000个顶点。将顶点添加到Graph中的时间太长了。我试图在功能上以不可变的方式做事。无论何时向图形添加顶点或边缘，都会得到一个新图形（我试图确保图形类型的构造函数没有做太多）。这是我用来从我的数据创建图表的客户端代码。

def GraphInstantiater: GraphLike[Int] =
{
  println( "Total number of Vertices: " + synMap.keys.size )
  def vertexAdder( ls: Iterable[Int], graph:GraphLike[Int] ): GraphLike[Int] = 
    if( ls.isEmpty) graph else vertexAdder( ls.tail, graph.addVertex( ls.head ) ) 

  val gr = vertexAdder( synMap.keys, new DiGraph[Int]( Map() ) )
  println( "Vertices added. Total: %d".format( gr.vertices.size ) )
  gr
}

我知道构建新的图形会占用周期，但鉴于我在构造函数中做的不多，它真的非常棒。重复创建顶点贴图会导致问题（它是图表类的参数之一）。关于这种方法的瓶颈是什么的任何想法将非常感激。如果您还需要任何其他信息，请告知我们。

Answer 1

作为对你回答的补充：每次拨打synMap.keys时，你确实无意中遍历整个ls.tail。

会发生什么：

Map.key返回Map.keySet的值，即custom immutable Set。
Set会覆盖一些内容，但会将tail和drop保留为默认实现。其tail实施（来自TraversableLike）仅调用drop。
这就是一切都崩溃的地方：它从IterableLike获得了drop的实现，并且只能用Iterable：迭代来做你能做的事情。因此，创建了一个新的构建器，删除了迭代器的头部，然后将迭代器添加到构建器，遍历所有键，以及一个新集合（ tail ）被退回。

您可以使用迭代器完全避免转换为列表，例如：

def vertexAdder( ls: Iterator[Int], graph:GraphLike[Int] ): GraphLike[Int] = {
  if(!ls.hasNext) 
    graph 
  else
    val h = ls.next
    vertexAdder( ls, graph.addVertex(h) ) 
}

然后：

val gr = vertexAdder( synMap.keysIterator, new DiGraph[Int]( Map() ) )

作为旁注，Set没有提供自己版本的tail，这有点令人遗憾。它可能只是占用它自己的迭代器的头部并返回自己减去该元素。

Answer 2

哇哇...我弄明白发生了什么事。在GraphInstantiater方法中，第一个通过synMap.keys的调用，key返回一个iterable [Int]。看起来像尾巴这是一个漫长的过程，很可能每次都会经历整个键集。

将通话更改为

val gr = vertexAdder( synMap.keys.toList, new DiGraph[Int]( Map() ) )

让一切都变得更快。有人知道在地图上调用keys时返回的容器的底层实现是什么？

需要帮助找出性能瓶颈

2 个答案: