Haskell 列表到树函数的渐近运行时间

我有一个

merge

函数，它需要时间

O（logn）

将两棵树合并为一棵树，还有一个

listToTree

函数，它将初始元素列表转换为单例树，并对每一对连续的树重复调用

merge

，直到只剩下一棵树

功能签名及相关实现如下：

merge :: Tree a -> Tree a -> Tree a --// O(log n) where n is size of input trees
singleton :: a -> Tree a            --// O(1)
empty :: Tree a                     --// O(1)
listToTree :: [a] -> Tree a         --// Supposedly O(n)

listToTree = listToTreeR . (map singleton)

listToTreeR :: [Tree a] -> Tree a
listToTreeR []     = empty
listToTreeR (x:[]) = x
listToTreeR xs     = listToTreeR (mergePairs xs)

mergePairs :: [Tree a] -> [Tree a]
mergePairs []       = []
mergePairs (x:[])   = [x]
mergePairs (x:y:xs) = merge x y : mergePairs xs

这是Chris Okasaki在纯函数数据结构中练习3.3的一个稍微简化的版本

根据练习，我现在将显示

listToTree

需要

O（n）

时间。但我不能：-(

存在对

listToTreeR

的递归调用，这意味着

ceil（logn）

调用

mergePairs

mergePairs

的运行时间取决于列表的长度和树的大小。列表的长度为

2^h-1

，树的大小为

log（n/（2^h））

，其中

h=log n

是第一个递归步骤，

h=1

是最后一个递归步骤。因此，每次调用

mergePairs

都需要时间

（2^h-1）*log（n/（2^h））

---

我无法进一步分析。有人能给我一个正确方向的提示吗？

就快到了。你已经知道这个表达式是

所以唯一的问题是计算这个和，使用log（AB）=loga+logb和log2n=N我们得到

，我们可以发现X=O（2m）=O（n），这是预期的

（如果要自己计算，请搜索“几何级数”，或使用整数近似求和。）