scala写算法-List、Stream、以及剑指Offer里部分题目基于scala解法

Stream(immutable)

Stream是惰性列表。实现细节涉及到lazy懒惰求值、传名参数等等技术(具体细节详见维基百科-求值策略)。

Stream和List是scala中严格求值和非严格求值两个代表性不可变函数式数据结构。

考虑字符串拼接的表达式"foo"+"bar"的到"foobar",空串""就是这个操作的单位元(identity，数学中又称幺元)，也就是说s+""或者""+s的值就是s。如果将三个字符串相加s+t+r，由于操作是可结合的(associative)，所以说((s+t)+r)和(s+(t+r))的结果一样。

在函数式编程里，把这类代数称为monoid。结合律(associativity)和同一律(identity)法则被称为monoid法则。

可折叠数据结构

比如List、Stream、Tree、Vector等等这类都是可折叠数据结构。monoid与折叠操作有着紧密联系。

比如words=List("aa","bb","cc")，运用折叠方法如下:

words.foldRight("")((a,b)=>a+b) == ((""+"aa")+"bb")+"cc"
words.foldLeft("")((a,b)=>a+b) == "aa"+("bb"+("cc"+""))

首先实现Stream.fold方法，然后用fold去实现map filter flatMap等等高阶函数(大可不必仅使用fold去编写其它函数，就像尺规作图没有刻度一样。这样写仅仅为了好玩，没有银弹No Silver Bullet)。至于map、flatMap是什么?函子(Functor)是对map的泛化，Monad是对flatMap的泛化(相关概念参见Fp in Scala)。

fold源码如下(采用尾递归):

  def fold[B](z: =>B)(f:(A,B)=>B):B={
    @tailrec
    def loop(stream: Stream[A])(result: =>B)(f:(A,B)=>B):B=stream match {
      case Empty     =>result
      case Cons(h,t) =>loop(t())(f(h(),result))(f)
    }
    loop(self)(z)(f)
  }

Stream实现如下:

trait Stream[+A] {self=>
  import Stream.{cons,empty}
  def fold[B](z: =>B)(f:(A,B)=>B):B={
    @tailrec
    def loop(stream: Stream[A])(result: =>B)(f:(A,B)=>B):B=stream match {
      case Empty     =>result
      case Cons(h,t) =>loop(t())(f(h(),result))(f)
    }
    loop(self)(z)(f)
  }
  def toList=fold(Nil:List[A])((a,b)=> ::(a,b)).invert
  def exits(p:A=>Boolean)=fold(false)((a,b)=>p(a)||b)
  def forall(p:A=>Boolean)=fold(true)((a,b)=>p(a)&&b)
  def invert=fold(Empty:Stream[A])((a,b)=>cons(a,b))
  def map[B](f:A=>B)=fold(Empty:Stream[B])((a,b)=> cons(f(a),b)).invert
  def ++[B>:A](stream:Stream[B])=invert.fold(stream)((a,b)=>{cons(a,b)})
  def flatMap[B>:A](f:A=>Stream[B])=fold(Empty:Stream[B])((a,b)=>{f(a)++b}).invert
  def filter(p:A=>Boolean)=fold(Empty:Stream[A])((a,b)=>p(a) match {
    case true  =>cons(a,b)
    case false =>b
  }).invert
  def take(n:Int)=fold((n,empty[A]))((a,b)=> b._1 match {
    case r if r >0=>(r-1,cons(a,b._2))
    case         0=>(0,b._2)
  })._2.invert
  def drop(n:Int)=fold((n,empty[A]))((a,b)=>b._1 match {
    case r if r>0 =>(r-1,b._2)
    case 0 => (0,cons(a,b._2))
  })._2
}
case class Cons[+A](h:()=>A,t:()=>Stream[A]) extends Stream[A]
case object Empty extends Stream[Nothing]
object Stream{
  def cons[A](hd: =>A,tl: =>Stream[A]) :Stream[A]={
    lazy val head=hd
    lazy val tail=tl
    Cons(()=>head,()=>tail)
  }
  def empty[A]:Stream[A]=Empty
  def apply[A](xs:A*):Stream[A]=
    if(xs.isEmpty)
      empty
    else
      cons(xs.head,apply(xs.tail:_*))
}

List(immutable)

scala中的List实现方式类似于c语言中的链表数据结构，但是不同于链表，List是不可变的。就像字符串操作a=b+c，字符串a加上字符串b的到新的字符串c，同理，不可变的List,al=bl++cl，listbl与listcl相连接的到新的listal,而bl与cl本身不变。相比抽象数据结构ADT，我更愿意把List称作代数数据结构。其不变性与函数式数据结构中的数据共享有关(通过复制与共享实现了不变性)。

至于exists forall takeWhile take filter map foldRight等函数均采用尾递归方式，无需考虑爆栈问题。与官方库基于CanBuildFrom这类的虚类型实现方式不同，本程序完全采用递归实现。

trait List[+A]{self=>
  def tail=self match {
    case Nil => Nil
    case _::t=>t
  }
  def init:List[A]=self match {
    case Nil=> Nil
    case h::Nil => Nil
    case h::t=> ::(h,t.init)
  }
  def print={
    def loop(list: List[A]):String=list match {
      case Nil=>"Nil"
      case h::t=>s"$h :: ${loop(t)}"
    }
    loop(self)
  }
  override def toString= print
  def setHead[B>:A](newHead:B)= ::(newHead,self.tail)
  def drop(n:Int):List[A]=n match {
    case 0=>self
    case _ if n>0 => self match {
      case _::t=> t.drop(n-1)
    }
    case _ if n<0 =>Nil
  }
  def dropWhile(p:A=>Boolean):List[A]=self match {
    case Nil=>Nil
    case h::t=>p(h) match {
      case true => t.dropWhile(p)
      case false=> self
    }
  }
  def ++[B>:A](list: List[B]):List[B]=self match {
    case Nil=>list
    case h::t=> ::(h,t++list)
  }
  def foldRight[B](z:B)(f:(A,B)=>B)={
    @tailrec
    def loop(list: List[A])(z:B)(f:(A,B)=>B):B=list match {
      case Nil =>  z
      case h::t => loop(t)(f(h,z))(f)
    }
    loop(self)(z)(f)
  }
  def invert=foldRight(Nil:List[A])(::(_,_))
  def length=foldRight(0)((_,b)=>b+1)
  def flatMap[B>:A](f:B=>List[B]):List[B]=self match {
    case Nil=> Nil
    case h::t=> f(h)++t.flatMap(f)
  }
  def map[B](f:A=>B)={
    @tailrec
    def loop(list: List[A])(result:List[B])(f:A=>B):List[B]=list match {
      case Nil=>result
      case h::t => loop(t)(::(f(h),result))(f)
    }
    loop(self)(Nil:List[B])(f).invert
  }
  def filter(p:A=>Boolean):List[A]={
    @tailrec
    def loop(list: List[A])(result:List[A])(p:A=>Boolean):List[A]=list match {
      case Nil => result
      case h::t => p(h) match {
        case true =>loop(t)(::(h,result))(p)
        case false=>loop(t)(result)(p)
      }
    }
    loop(self)(Nil)(p).invert
  }
  def take(n:Int):List[A]={
    @tailrec
    def loop(list: List[A])(result:List[A])(n:Int):List[A]=list match {
      case Nil=> result
      case h::t => n match {
        case 0        =>result
        case _ if n>0 =>loop(t)(::(h,result))(n-1)
      }
    }
    loop(self)(Nil)(n).invert
  }
  def takeWhile(p:A=>Boolean):List[A]={
    @tailrec
    def loop(list: List[A])(result:List[A])(p:A=>Boolean):List[A]=list match {
      case Nil=>result
      case h::t=>p(h) match {
        case true  => loop(t)(::(h,result))(p)
        case false => result
      }
    }
    loop(self)(Nil)(p).invert
  }
  def forall(p:A=>Boolean):Boolean={
    @tailrec
    def loop(list: List[A])(result:Boolean)(p:A=>Boolean):Boolean=list match {
      case Nil => result
      case h::t => p(h) match {
        case true => loop(t)(result)(p)
        case false=>false
      }
    }
    loop(self)(true)(p)
  }
  def exists(p:A=>Boolean):Boolean={
    @tailrec
    def loop(list: List[A])(result:Boolean)(p:A=>Boolean):Boolean=list match {
      case Nil  => result
      case h::t => p(h) match {
        case true=>true
        case false=>loop(t)(result)(p)
      }
    }
    loop(self)(false)(p)
  }
}
case class ::[+A](h:A,t:List[A]) extends List[A]
case object Nil extends List[Nothing]
object List{
  def empty[A]:List[A]=Nil
  def apply[A](xs:A*):List[A]={
    if(xs.isEmpty) empty[A]
    else ::(xs.head,apply(xs.tail:_*))
  }
}

Tree

trait Tree[+A] {
}
case object EmptyNode extends Tree[Nothing]{
  override def toString: String = "Nil"
}
case class Node[+A](value:A,left:Tree[A],right:Tree[A]) extends Tree[A]
object Tree{
  def node[A](value:A,left:Tree[A]=EmptyNode,right:Tree[A]=EmptyNode)=Node(value,left,right)
  def empty[A]:Tree[A]=EmptyNode
}

剑指Offers上的有关题目(基于scala解法)

数组中只出现一次的数字

0	0	0 ^ 0 = 0
0	1	0 ^ 1 = 1
1	1	1 ^ 1 = 0

一个整型数组里除了一个数字外，其它数字均出现两次，如数组Array(2, 3, 6, 3, 2, 5, 5)，返回结果应该为6，程序一句话就ok