List Scala中的递归程序不'；跑不动

我正在尝试用Scala编写一个程序，使用递归来查看两个列表是否不相交。这是我第一次用Scala编写程序

object Main {
    def member(x:Int,lst:List[Int]):Boolean= {
        if (lst == Nil)
            return false
        else
            if (x != lst.head)
                return member(x, lst.tail)
            else
                return true
    }

    def disjoint(s1:List[Int], s2:List[Int]):Boolean= {
        if (s1 == Nil)
            return true
        else
            if (member(s1.head,s2))
                return false
            else
                return disjoint(s1.tail, s2)
    }
     def main(args: Array[String]) {
        val lst1 = 2 :: (6 :: (1 :: Nil))
        val lst2 = 1 :: (3 :: (5 :: (7 :: (9 :: (11 :: Nil)))))
        val lst3 = disjoint(lst1, lst2)
     }
}

---

它编译但不运行。我们将非常感谢您的帮助。

这可能就是您想要的：

def areDisjoint[T](s1: Seq[T], s2: Seq[T]): Boolean =
  (s1.toSet & s2.toSet).isEmpty

val lst1 = List(2, 6, 1)
val lst1a = List(2, 6)
val lst2 = List(1, 3, 5, 7, 9, 11)
println(areDisjoint(lst1, lst2))
println(areDisjoint(lst1a, lst2))

=>

---

诀窍是使用上的

&

操作符为您完成工作

Set

使用哈希有效地测试给定对象是否为成员。

这可能就是您要查找的：

def areDisjoint[T](s1: Seq[T], s2: Seq[T]): Boolean =
  (s1.toSet & s2.toSet).isEmpty

val lst1 = List(2, 6, 1)
val lst1a = List(2, 6)
val lst2 = List(1, 3, 5, 7, 9, 11)
println(areDisjoint(lst1, lst2))
println(areDisjoint(lst1a, lst2))

=>

---

诀窍是使用上的

&

操作符为您完成工作

Set

使用散列有效地测试给定对象是否为成员。

如果您真的想使用递归来查看如何在Scala中递归列表，下面是如何：

def isMember(x: Int, l: List[Int]): Boolean =
  l match {
    case Nil => false
    case head :: tail => x == head || isMember(x, tail)
  }

def areDisjoint(l1: List[Int], l2: List[Int]): Boolean =
  l1 match {
    case Nil => true
    case head :: tail => !isMember(head, l2) && areDisjoint(tail, l2)
  }

match

does，它提供了一种从

列表中提取头部和尾部的语法简单方法。请注意，实际上这并不是好的Scala代码，原因有三：

它进行线性搜索，并在O（n^2）时间内运行。
Set
版本运行得更快，至少在大型列表上是如此

列表
已经有一个内置的
。包含
方法（请参阅），因此您确实不需要编写
isMember

它仅限于处理
列表[Int]
。
Seq[T]
版本适用于任何类型的序列，包含任何类型的项

如果您真的想使用递归来查看如何在Scala中递归列表，下面是如何使用的：

def isMember(x: Int, l: List[Int]): Boolean =
  l match {
    case Nil => false
    case head :: tail => x == head || isMember(x, tail)
  }

def areDisjoint(l1: List[Int], l2: List[Int]): Boolean =
  l1 match {
    case Nil => true
    case head :: tail => !isMember(head, l2) && areDisjoint(tail, l2)
  }

match
does，它提供了一种从
列表中提取头部和尾部的语法简单方法。请注意，实际上这并不是好的Scala代码，原因有三：

它进行线性搜索，并在O（n^2）时间内运行。
Set
版本运行得更快，至少在大型列表上是如此

列表
已经有一个内置的
。包含
方法（请参阅），因此您确实不需要编写
isMember

它仅限于处理
列表[Int]
。
Seq[T]
版本适用于任何类型的序列，包含任何类型的项

我得到的是lst3:Boolean=false您可以在这里省略所有
return
单词，顺便说一下我得到的是lst3:Boolean=false您可以在这里省略所有
return
单词，顺便说一下，我希望它在lisp样式列表中工作，其中lst.head是car，lst.tail是cdr。确实如此
Seq[T]
使它可以在任何类型的序列上工作：
List
，
Array
，等等。我用val lst1=7:（6:（1:：Nil））和val lst2=1:（3:（5:（7:（9:（11:（Nil）；））尝试了它，但它不起作用。它仍然返回false。这些列表不是不相交的。每个包含一个
1
。顺便说一句，
List（7,6,1）
与
7:：（6:：（1:（Nil））
@OshaMan它应该返回false，我希望它在lisp样式的列表上工作，其中lst.head是car，lst.tail是cdr。它确实如此
Seq[T]
使它可以在任何类型的序列上工作：
List
，
Array
，等等。我用val lst1=7:（6:（1:：Nil））和val lst2=1:（3:（5:（7:（9:（11:（Nil）；））尝试了它，但它不起作用。它仍然返回false。这些列表不是不相交的。每个包含一个
1
。顺便说一句，
List（7,6,1）
与
7:：（6:：（1:（Nil））
@OshaMan它应该返回false