scala操作List函数

1.定义反转函数

def rev[T](xs:List[T])=(List[T]() /:xs){(ys,y)=>y::ys}

2.列表排序：

List[T] stor(_<_)

3.列表归并排序：

原理：首先如果列表长度为零或仅有一个元素，它就已经排好序的，因此可以不加改变的返回。

长列表可以拆成两个子列表，每个包含大概一半的原表元素。每个子列表采用堆排序函数的递归调用完成排序，然后

再归并操作把产生的两个排号的序的列表合并在一起。时间复杂度为nlog(n)级别。

scala>:past
def msort[T](less:(T,T)=>Boolean)(xs:List[T]):List[T]={
	def merge(xs:List[T],ys:List[T]):List[T]=
	(xs,ys) match{
		case(Nil,_)=>ys
		case(_,Nil)=>xs
		case(x::xs1,y::ys1)=>
			if(less(x,y)) x::merge(xs1,ys)
			else y::merge(xs,ys1)
	}
	val n=xs.length/2
	if(n==0) xs
	else{
		val (ys,zs)=xs splitAt n
		merge(msort(less)(ys),msort(less)(zs))
	}
}

scala> msort((x:Int,y:Int)=>x<y)(List(5,7,2,5,7,9,5,3,2))

msort不能正确推断实例类型，不能这样写 msort(_>_)(List[])

唯一解决只能时明确把参数类型传递给msort,如：

msort[String](_>_)(List("asd","bsfd","fe"))

还有一种是重写msort方法交换参数顺序

def msortSwapped[T](xs:List[T])(less:(T,T)=>Boolean):List[T]={

//与msort同样的实现，不过交换了参数顺序

}

现在就以执行类型推断

msortSwapped(List("ads","qwef","df"))(_>_)

通常，一旦有需要推断多态方法参数类型时，类型推断就只会参考第一个参数列表中所有的参数类型，但不会参考之后的其他参数，因为函数时柯里化的方法，带有两个参数列表，所以第二个参数（也就是说，那个函数值）将不会用来做决定方法类型参数的参考。

4.创建Queue类

//夹在类名与其参数之间的private修饰符表面Queue的构造器是私有的，它只能被类本身
//及伴生对象访问，类名Queue仍然是公开的，因此可以继续使用这个类，但是不能调用它的构造器
//为了解决这个问题可以添加用初始元素序列，比较简洁的做法是创建的工厂方法，做法是定义一个
//与类同名的Queue对象及apply方法。
class Queue[T] private(
	private val leading:List[T],
	private val trailing:List[T]
){
	private def mirror=
		if(leading.isEmpty) new Queue(trailing.reverse,Nil)
		else this
	def head=mirror.leading.head
	def tail={
		val q=mirror
		new Queue(q.leading.tail,q.trailing)
	}
	def append(x:T)=
		new Queue(leading,x::trailing)
}
object Queue{
	//用初始元素'xs'构造队列
	def apply[T](xs:T*)=new Queue[T](xs.toList,Nil)
}

注意：方法名为apply，因此客户可以用类似Queue（1，2，3，4)这样的表达式创建队列。由于Queue是对象不是函数，这个表达式会被扩展为Queue.apply(1，2，3，4)。

猜你喜欢