使用scala获取列表中的第一个非递归元素

获取编译错误-正向引用扩展了值lst的定义：

    val lt = List(1,2,3,3,2,4,5,1,5,7,8,7) 
    var cond = false 
    do 
    { 
        var cond = if (lt.tail contains lt.head) true else false 
        if (cond == true) { 
           val lst : List[Int]= lt.filter(_!=lt.head)
           val lt = lst
        }
        else { 
          println(lt.head)
        }
    }
    while(cond == false)

整个列表中的第一个非重复元素 使用scala获取列表中的第一个非递归元素

您可以使用

filter

和

count

作为

val firstNonRecurrringValue = lt.filter(x => lt.count(_ == x) == 1)(0)

所以

firstnonrecurringvalue

是

4

列表中元素后的第一个非重复元素 但是看看你的

do-while

代码，似乎你在试图打印第一个元素，而这个元素在它之后不会重复出现。为此，下面的代码应该可以工作

val firstNonRecurringValue = lt.zipWithIndex.filter(x => lt.drop(x._2).count(_ == x._1) == 1)(0)._1

现在

firstNonRecurringValue

应该是整个列表中的第一个非重复元素

3

使用scala获取列表中的第一个非递归元素

您可以使用

filter

和

count

作为

val firstNonRecurrringValue = lt.filter(x => lt.count(_ == x) == 1)(0)

所以

firstnonrecurringvalue

是

4

列表中元素后的第一个非重复元素 但是看看你的

do-while

代码，似乎你在试图打印第一个元素，而这个元素在它之后不会重复出现。为此，下面的代码应该可以工作

val firstNonRecurringValue = lt.zipWithIndex.filter(x => lt.drop(x._2).count(_ == x._1) == 1)(0)._1

现在

firstNonRecurringValue

应该是

3

您可以使用

find

实现“Get first”，也可以使用

count==1

实现“non-recurrence”，因此代码是

lt.find(x => lt.count(_ == x) == 1)

这将返回一个

选项[Int]

，该选项可以按常规方式取消勾选

此算法很清晰，但效率不高，因此对于很长的列表，您可能需要预先计算计数，或者使用递归函数来实现原始算法。这可能不太清楚，但效率更高，因此，除非你能证明效率低下是造成问题的原因，否则就不要这样做

更新 下面是预计算每个值的计数的示例。这对于长列表可能更快，因为

Map

操作通常是O（logn），因此对于以前的版本，函数是O（nlogn）而不是O（n2）

def firstUniq[A](in: Seq[A]): Option[A] = {
  val m = mutable.Map.empty[A, Int]

  for (elem <- in) {
    m.update(elem, m.getOrElseUpdate(elem, 0) + 1)
  }

  val singles = m.filter(_._2 == 1)

  in.find(singles.contains)
}

def firstUniq[A]（in:Seq[A]）：选项[A]={
val m=mutable.Map.empty[A，Int]
对于（elem您可以使用
find
实现“Get first”，也可以使用
count==1
实现“non-recurtive”，因此代码是

lt.find(x => lt.count(_ == x) == 1)

这将返回一个
选项[Int]
，该选项可以按常规方式取消勾选

此算法清晰但效率不高，因此对于一个很长的列表，您可能需要预先计算计数，或者使用递归函数来实现原始算法。此算法虽然不太清晰，但效率更高，因此请避免使用此算法，除非您能证明效率低下导致了问题

更新
下面是一个预计算每个值的计数的示例。这对于长列表可能更快，因为
Map
操作通常是O（logn），因此对于以前的版本，函数是O（nlogn）而不是O（n2）

def firstUniq[A](in: Seq[A]): Option[A] = {
  val m = mutable.Map.empty[A, Int]

  for (elem <- in) {
    m.update(elem, m.getOrElseUpdate(elem, 0) + 1)
  }

  val singles = m.filter(_._2 == 1)

  in.find(singles.contains)
}

def firstUniq[A]（in:Seq[A]）：选项[A]={
val m=mutable.Map.empty[A，Int]
for（elem
cond
不在范围内。您正在定义变量
lt
两次，一次在循环外，一次在循环内。嗯。是的，我错误地定义了这些变量！。解决方案在我更正后生成了预期结果。var lt=List（1,2,3,3,2,4,5,5,7,8,7,4）var cond=false do{cond=if（lt.tail包含lt.head）true else false如果（cond==true）{var lst:List[Int]=lt.filter（！=lt.head）lt=lst}else{println（lt.head）}而（cond！=false）
cond
不在范围内。您正在定义变量
lt
两次，一次在循环外，一次在循环内。嗯。是的，我错误地定义了这些变量。解决方案在我更正后生成了预期结果。var lt=List（1,2,3,3,2,4,5,1,5,7,8,7,4）var cond=false do{cond=if（lt.tail包含lt.head）true else false如果（cond==true）{var lst:List[Int]=lt.filter（！=lt.head）lt=lst}else{println（lt.head）}而（cond！=false）