找到重复项时拆分列表

Question

我在 Scala 中有一个元素列表，我正在寻找一种在找到重复项时拆分列表的方法。

例如：List(x,y,z,e,r,y,g,a) 将转换为 List(List(x,y,z,e,r),List(y,g,a)) 或List(x,y,z,x,y,z) 至List(x,y,z), List(x,y,z) 和List(x,y,z,y,g,x) 到List(x,y,z), List(y,g,x)

有没有比单独迭代和检查每个元素更有效的方法？

Answer 1

快速而肮脏的O(n) 使用O(n) 额外内存：

import scala.collection.mutable.HashSet
import scala.collection.mutable.ListBuffer

val list = List("x", "y", "z", "e", "r", "y", "g", "a", "x", "m", "z")

var result = new ListBuffer[ListBuffer[String]]()
var partition = new ListBuffer[String]()

list.foreach { i => 
    if (partition.contains(i)) {
        result += partition
        partition = new ListBuffer[String]()
    }
    partition += i
}

if (partition.nonEmpty) {
    result += partition
}
result

ListBuffer(ListBuffer(x, y, z, e, r), ListBuffer(y, g, a, x, m, z))

Answer 2

此解决方案有一些注意事项：

• 虽然我认为它比 O(n^2) 更好，但我并没有声称它是“性能”，这是蛮力。
• 这是假设您在找到重复项时进行拆分，其中“重复项”表示“存在于先前拆分项中的内容”。我只检查最后一段来作弊。原因是我认为它澄清了如何使用foldLeft，这是一种很自然的方式。
• 这里的一切都颠倒过来了，但保持秩序。这可以很容易地纠正，但会增加一个额外的 O(n)（累积）调用，并且实际上可能不需要（取决于您正在使用它做什么）。

代码如下：

def partition(ls: List[String]): List[ListSet[String]] = {
  ls.foldLeft(List(ListSet.empty[String]))((partitionedLists, elem:String) => {
    if(partitionedLists.head.contains(elem)) {
      ListSet(elem) :: partitionedLists
    } else {
      (partitionedLists.head + elem) :: partitionedLists.tail
    }
  })
}

partition(List("x","y","z","e","r","y","g","a"))
// res0: List[scala.collection.immutable.ListSet[String]] = List(ListSet(r, e, z, y, x), ListSet(a, g, y))

我使用ListSet 来获得Set 的好处和适合您的用例的排序。

foldLeft 是一个函数，它接受一个累加器值（在本例中为List(ListSet.empty[String])）并在它通过集合的元素时对其进行修改。如果我们像这里所做的那样将累加器构造成一个段列表，当我们完成时，它将拥有原始列表的所有有序段。

Answer 3

一个语句尾递归版本（但效率不高，因为列表中有contains）

var xs = List('x','y','z','e','r','y','g','a') 

def splitAtDuplicates[A](splits: List[List[A]], right: List[A]): List[List[A]] = 
  if (right.isEmpty)// done
    splits.map(_.reverse).reverse
  else if (splits.head contains right.head) // need to split here
    splitAtDuplicates(List()::splits, right)
  else // continue building current sublist
    splitAtDuplicates((right.head :: splits.head)::splits.tail, right.tail)

使用Set 加快速度以跟踪我们迄今为止所看到的：

def splitAtDuplicatesOptimised[A](seen: Set[A], 
                                  splits: List[List[A]],
                                  right: List[A]): List[List[A]] = 
  if (right.isEmpty)
     splits.map(_.reverse).reverse 
  else if (seen(right.head))
     splitAtDuplicatesOptimised(Set(), List() :: splits, right)
  else
    splitAtDuplicatesOptimised(seen + right.head,
                              (right.head :: splits.head) :: splits.tail, 
                              right.tail)

Answer 4

您基本上需要使用查找表进行迭代。我可以为以下不可变和函数式 tailrec 实现提供帮助。

import scala.collection.immutable.HashSet    
import scala.annotation.tailrec

val list = List("x","y","z","e","r","y","g","a", "x", "m", "z", "ll")

def splitListOnDups[A](list: List[A]): List[List[A]] = {
  @tailrec
  def _split(list: List[A], cList: List[A], hashSet: HashSet[A], lists: List[List[A]]): List[List[A]] = {
    list match {
      case a :: Nil if hashSet.contains(a) => List(a) +: (cList +: lists)
      case a :: Nil => (a +: cList) +: lists
      case a :: tail if hashSet.contains(a) => _split(tail, List(a), hashSet, cList +: lists)
      case a :: tail => _split(tail, a +: cList, hashSet + a, lists)
    }
  }

  _split(list, List[A](), HashSet[A](), List[List[A]]()).reverse.map(_.reverse)
}

def splitListOnDups2[A](list: List[A]): List[List[A]] = {
  @tailrec
  def _split(list: List[A], cList: List[A], hashSet: HashSet[A], lists: List[List[A]]): List[List[A]] = {
    list match {
      case a :: Nil if hashSet.contains(a) => List(a) +: (cList +: lists)
      case a :: Nil => (a +: cList) +: lists
      case a :: tail if hashSet.contains(a) => _split(tail, List(a), HashSet[A](), cList +: lists)
      case a :: tail => _split(tail, a +: cList, hashSet + a, lists)
    }
  }

  _split(list, List[A](), HashSet[A](), List[List[A]]()).reverse.map(_.reverse)
}

splitListOnDups(list)
// List[List[String]] = List(List(x, y, z, e, r), List(y, g, a), List(x, m), List(z, ll))

splitListOnDups2(list)
// List[List[String]] = List(List(x, y, z, e, r), List(y, g, a, x, m, z, ll))