集合

简介

• 集合：一个包含不重复元素的序列；
• 与映射类似，集合也是按树状实现的，因此是有序的；
• Data.Set模块实现了与集合相关的功能；

定义

Data.Set.fromList :: Ord a => [a] -> Set a

与Data.Map.fromList函数类似，将列表转换为集合。

import qualified Data.Set as S

text1 = "The abyss looks into you."
text2 = "I think, therefore I am."
set1 = S.fromList text1 -- fromList " .Tabehiklnostuy"
set2 = S.fromList text2 -- fromList " ,.Iaefhikmnort"

Data.Set.empty :: Set a

空集合。

exp1 = S.empty -- fromList []

Data.Set.singleton :: a -> Set a

返回一个包含单个元素的集合。

exp2 = S.singleton 3 -- fromList [3]

添加

Data.Set.insert :: Ord a => a -> Set a -> Set a

将元素插入集合最后。

exp3 = S.insert 10 $ S.fromList [1 .. 3] -- fromList [1,2,3,10]

删除

Data.Set.delete :: Ord a => a -> Set a -> Set a

从集合删除所有匹配元素。

exp4 = S.delete 4 $ S.fromList [3, 4, 5, 4, 3] -- fromList [3,5]

Data.Set.deleteAt :: Int -> Set a -> Set a

从集合删除指定索引对应值。

exp5 = S.deleteAt 2 $ S.fromList [1 .. 5] -- fromList [1,2,4,5]

访问

Data.Set.take :: Int -> Set a -> Set a

从集合中取出相应数量的元素并返回新集合。

exp6 = S.take 3 $ S.fromList [1 .. 5] -- fromList [1,2,3]

Data.Set.drop :: Int -> Set a -> Set a

从集合中移除相应数量的元素并返回剩余元素。

exp7 = S.drop 3 $ S.fromList [1 .. 5] -- fromList [4,5]

统计

Data.Set.size :: Set a -> Int

统计集合所包含元素的个数。

判断

Data.Set.null :: Set a -> Bool

判断集合是否为空。

Data.Set.member :: Ord a => a -> Set a -> Bool

判断元素是否属于集合。

Data.Set.isSubsetOf :: Ord a => Set a -> Set a -> Bool

判断第一个集合是否为第二个集合的子集。

exp8 = S.fromList [2] `S.isSubsetOf` S.fromList [2, 3] -- True
exp9 = S.fromList [2] `S.isSubsetOf` S.fromList [2]    -- True

Data.Set.isProperSubsetOf :: Ord a => Set a -> Set a -> Bool

判断第一个集合是否为第二个集合的真子集。

exp10 = S.fromList [2] `isProperSubsetOf` S.fromList [2, 3]
        -- True
exp11 = S.fromList [2] `S.isProperSubsetOf` S.fromList [2]
        --False

运算

Data.Set.intersection :: Ord a => Set a -> Set a -> Set a

对两个集合进行交集运算。

exp12 = S.intersection set1 set2 -- fromList " .aehiknot"

Data.Set.difference :: Ord a => Set a -> Set a -> Set a

对第一个集合进行差集运算。

exp13 = S.difference set1 set2 -- fromList "Tblsuy"

Data.Set.union :: Ord a => Set a -> Set a -> Set a

对两个集合进行并集运算。

exp14 = S.union set1 set2 -- fromList " ,.ITabefhiklmnorstuy"

重构

Data.Set.map :: Ord b => (a -> b) -> Set a -> Set b

对每个元素进行相同操作。

exp15 = S.map (+ 1) $ S.fromList [3, 2, 5, 3] -- fromList [3,4,6]

Data.Set.filter :: (a -> Bool) -> Set a -> Set a

对集合元素进行筛选。

exp16 = S.filter odd $ S.fromList [3, 4, 5, 3, 4] -- fromList [3,5]

Data.Set.toList :: Set a -> [a]

将集合转换为列表。

小技巧

使用fromList和toList函数对大型列表去重的效率比Data.List.nub函数高得多。

备注

Data.List.nub函数只要求元素类型为Eq成员，而fromList和toList函数要求元素类型为Ord成员。

Data.List.nub函数不会打乱原列表顺序，而fromList和toList函数则会。

exp17 = S.toList $ S.fromList [3, 4, 3, 2, 6, 5, 6] -- [2,3,4,5,6]