Haskell复习笔记(二)

Haskell中的递归

递归就是定义函数以调用自身的方式，关于递归解决问题的实例有很多，如斐波那契数列，还有汉诺塔问题，递归也正是Haskell中用来解决循环问题的关键。

自定义maxinum函数

maxinum取一组可供排序的list作为参数，并且返回其中的最大值。

我们要弄懂一点，一个list的最大值，就是第一个元素，和后面所有袁旭相比较的结果。

maxinum :: (Ord a) => [a]->a

maxinum [] = error "empty"

maxinum [x]=x

maxinum (x:xs)

    | x > maxtail = x

    | otherwise = maxtail

    where maxtail = maxinum xs

自定义replicate函数

replicate函数接收一个int和一个元素作为参数，返回int个元素的list。

replicate :: (N um i ,Ord i ) =>i->a ->[a]

replicate n x

    | n <=0 =[]

    | otherwise = x:replicate(n-1) x

Note ： Num不是Ord的子集，也就是说数字不一定拘泥于排序。

自定义take函数

take函数接收一个int和一个list作为参数，对list进行切片。

take :: (Num i ,Ord i) =>i->[a]->[a]

take n _

    | n <=0    = []

take _ []    =[]

take n(x:xs)=x:take(n-1) xs

自定义reverse函数

在haskell中支持无限list，是一种无限的数据结构，，无限list的好处就在于我们可以在任意位置令其断开。

reverse :: [a] -> [a]

reverse    []=[]

reverse    (x:xs) = reverse xs ++ [x]

自定义repeat函数

repeat函数取一个元素作为参数，然后返回无限长的仅存在该元素的list。

repeat :: a ->[a]

repeat x = x:repeat x

快速排序

排过顺序的list就是令所有小于等于头部的list在左边，大于等于头部的list在右边，也就是无序区元素的归位操作。

quicksort :: (Ord a) =>[a] ->[a]

quicksort [] = []

quicksort (x:xs) =

    let smallersort = quicksort[a|a<- xs, a <=x]    -- 属于xs，并且小于x

    let biggersort = quick[a|a<- xs,a>x]

    in smallersort ++ x ++ biggersort

用递归来思考

递归的固定模式：先定义一个边界条件，在定义一个函数，让它从一堆元素中处理一件事情后，再把余下的元素重新交给这个函数，直到达到边界条件。

比如 sum 函数就是一个list的头部与其尾部的sum。

所谓的边界条件就是为了避免进程出错而设置的保护措施，也就是在定义递归时需要思考它在什么条件下不可用，终止递归。

高端函数

高端函数就是可以接受函数作为参数也可以返回函数作为结果，Haskell的思想就是定义问题是什么来解决问题。

本质上，Haskell的所有函数都只有一个参数，所有的多参数函数都是curried functions，比如max函数，它会先回传一个含有一个参数的函数，5为参数对它进行调用，然后返回，也就是(max 4) 5,所以说我们定义函数使->代表的就是回传函数，后面接的就是本次或下一次传入的参数。

lambda函数

lambda函数就是匿名函数，有时我们要传递给高端函数一个函数，而这函数我们只用一次，那么编写一个匿名函数是最好的选择。

编写lambda，就写 \ 参数 ->函数体

filter函数

filter函数取一个限制条件和一个list，回传该list中所有符合该条件的元素。

类型声明：

filter :: (a -> Bool) -> [a] ->[a]

fiter _ [] = []

filter p(x:xs)

    | p x    =x: filter p xs

    | otherwise = filter p xs

map函数

map取一个函数和list作为参数，遍历该list的每个元素来调用该函数返回一个新的list。