Scala Recursion for the union of trees
Here is the implementation of binary trees that I have seen in Martin Odersky's video lectures on Coursera, week 3:
abstract class IntSet
{
  def incl(x: Int): IntSet
  def contains(x: Int): Boolean
  def union(other: IntSet): IntSet
}
object Empty extends IntSet
{
  def contains(x: Int): Boolean = false
  def incl(x: Int): IntSet = new NonEmpty(x, Empty, Empty)
  def union(other: IntSet): IntSet = other
  override def toString = "."
}
class NonEmpty(elem: Int, left: IntSet, right: IntSet) extends IntSet
{
  def contains(x: Int): Boolean =
    if (x<elem) left contains x
    else if (x > elem) right contains x
    else true
  def incl(x: Int): IntSet =
    if (x<elem) new NonEmpty(elem, left incl x, right)
    else if (x > elem) new NonEmpty(elem, left, right incl x)
    else this
  def union(other: IntSet): IntSet =
    ((left union right) union other) incl elem
  override def toString = "{" + left + elem + right + "}"
}
So Empty and NonEmpty follow the standards outlined by the IntSet. What I am interested in, is the union method in the NonEmpty class. I would like to understand how it works.
 I have made a small depiction below to explain my thinking process:  
To me it appears as if there is an infinite loop there. But I am more than certain that I have made an evaluation mistake somewhere below:
Let's see if I can parse this out using your diagram.
 ((left union right) union other) incl elem becomes: ((L1 u R1) u OE1) incl 5  
 Expand the inner parentheses to: ((L2 u R2) u R1) incl 3  
 L2 and R2 are both empty so this collapses to: R1 incl 3 , which is a new NonEmpty that isn't in your diagram.  
 Plug this into the original formula: ((R1 incl 3) u OE1) incl 5  
 This is getting harder to diagram but, as you can see, we've removed L1 from the calculations and replaced R1 with a new, slightly larger, NonEmpty .  Continuing in this manner everything will be reduced to a new IntSet that includes all the values from the previous.  
上一篇: Android Jar库
下一篇: 斯卡拉递归树的联合
