【F#2.0系列】使用F#的List

最新推荐文章于 2024-10-18 00:00:00 发布

weixin_33749131

最新推荐文章于 2024-10-18 00:00:00 发布

阅读量117

点赞数

文章标签：数据结构与算法

版权

创建一个list：

语法	描述	示例
[]	空list	[]
expr :: expr	将一个项加入一个list	1 :: [2; 3]
[expr; ...; expr]	列举项创建list	[1; 2; 3]
[expr .. expr]	连续的数字	[1 .. 99]
[ for x in list ... ]	通过运算生成list（类似于Linq里的select）	[ for x in 1..99 -> x * x ]
expr @ expr	合并两个list	[1; 2] @ [3]

操作示例：

let oddPrimes = [3; 5; 7; 11]

let morePrimes = [13; 17]

let primes = 2 :: (oddPrimes @ morePrimes)

val primes : int list = [2; 3; 5; 7; 11; 13; 17]

list同样是不可变的(immutable)：操作符“::”并未真正改变原list本身，相反的，它创建了一个新的list。示例：

> let people = [ "Adam"; "Dominic"; "James" ];;

val people : string list

> people;;

val it : string list = [ "Adam"; "Dominic"; "James" ]

> "Chris" :: people;;

val it : string list = [ "Chris"; "Adam"; "Dominic"; "James" ]

> people;;

val it : string list = [ "Adam"; "Dominic"; "James" ]

如你所见，people并未被改变。在内存中，F#将list表示为关联的list；每个F#的list的值(value)包含了自身的值以及指向下一个列表的指针。也就是说当你使用“::”来创建一个新的list的时候，新list的尾部就包含了一个指向老list的指针。

在我看来，通过不可变性与指针的结合，提高了list的内存利用效率。

我们再看一个分解(decompose)list的例子：

let oddPrimes = [3; 5; 7; 11]

let printFirst primes =

    match primes with

    | h :: t -> printfn "The first prime in the list is %d" h

    | [] -> printfn "No primes found in the list"

> printFirst oddPrimes;;

The first prime in the list is 3

val it : unit = ()

程序通过h::t来分解list，h代表list的第一个元素，t代表其后续。[]代表空list。match是匹配开始关键字，primes是匹配源，通过|表示各种匹配条件。感觉类似于switch case。

F#包含了一个List模块。其提供了一些功能：

方法	类型	描述
List.length	'T list -> int	返回list长度
List.head	'T list -> 'T	返回非空list的第一个元素
List.tail	'T list -> 'T list	返回非空list中除了第一个元素外的其他所有元素
List.init	int -> (int -> 'T) -> 'T list	通过一个可以通过索引生成值的函数来构造一个定长list
List.append	'T list -> 'T list -> 'T list	返回一个合并后的list
List.filter	('T -> bool) -> 'T list -> 'T list	返回一个新的过滤后的列表。
List.map	('T -> 'U) -> 'T list -> 'U list	将一个list通过一个转换函数转换为另一个list
List.iter	('T -> unit) -> 'T list -> unit	对list中的每个项执行一次指定的函数
List.unzip	('T * 'U) list -> 'T list * 'U list	zip操作的反向操作
List.zip	'T list -> 'U list -> ('T * 'U) list	将两个拥有相同长度的list合并成一个新的list，相同index的项会组合成元组(tuple)，并作为新list中的项。
List.toArray	'T list -> 'T[]	从一个list生成一个array
List.ofArray	'T[] -> 'T list	从一个array生成一个list

上面的说明还都是比较抽象的，示例如下：

> List.head [5; 4; 3];;

val it : int = 5

> List.tail [5; 4; 3];;

val it : int list = [ 4; 3 ]

> List.map (fun x -> x*x) [1; 2; 3];;

val it : int list = [ 1; 4; 9 ]

> List.filter (fun x -> x % 3 = 0) [2; 3; 5; 7; 9];;

val it : int list = [ 3; 9 ]

从上例可得知，我们可以使用fun关键字来表示匿名函数。

数据类型大概可以分为可变(mutable)的和不可变(immutable)的两种。不可变类型有时会被称为持久(persistent)或函数体(functional)。F#中常用的不可变类型：

· 元组(Tuple)和选项(option)：他们都是不可变类型并且是F#的基本(basic workhorse)

· 不可变链表’T list：非常适合从左至右的便利。但不适合随机访问。随机访问的时间复杂度为O(n)，n为list的长度。全名为：Microsoft.FSharp.Collections.List<’T>。

· 基于平衡树(balanced tree)的不可变set类型：非常适合添加，访问和合并，O(log(n))的访问时间复杂度。因为此类型是不可变的，内部的节点可以在不同的sets之间共享。

· 基于平衡树(balanced tree)不可变的map类型：简单的说就是不可变的字典类型(dictionary)。也同样拥有O(log(n))的访问时间复杂度。

转载于:https://www.cnblogs.com/pandora/archive/2010/08/30/FSharp_UsingList.html

关注