如何获取列表的最后 n 个元素

Question

要获取列表xs 的最后一个n 元素，我可以使用reverse (take n (reverse xs))，但这不是很好的代码（它在返回任何内容之前将完整列表保留在内存中，并且结果不共享与原始列表）。

如何在 Haskell 中实现 lastR 函数？

Answer 1

这应该具有仅迭代列表长度一次的属性。 N 代表drop n，n - 1 代表 zipLeftover。

zipLeftover :: [a] -> [a] -> [a]
zipLeftover []     []     = []
zipLeftover xs     []     = xs
zipLeftover []     ys     = ys
zipLeftover (x:xs) (y:ys) = zipLeftover xs ys

lastN :: Int -> [a] -> [a]
lastN n xs = zipLeftover (drop n xs) xs

这是一个更短的替代方案，也许更好，因为正如 Satvik 指出的那样，使用递归运算符通常比使用显式递归更好。

import Data.Foldable

takeLeftover :: [a] -> t -> [a]
takeLeftover [] _ = []
takeLeftover (x:xss) _ = xss

lastN' :: Int -> [a] -> [a]
lastN' n xs = foldl' takeLeftover xs (drop n xs)

还要注意 Will Ness 在下面的评论 takeLeftover 只是：

takeLeftover == const . drop 1

这让事情变得相当整洁：

lastN' :: Int -> [a] -> [a]
lastN' n xs = foldl' (const . drop 1) xs (drop n xs)
-- or
-- lastN' n xs = foldl' (const . drop 1) <*> drop n

Answer 2

据我所知，你可以使用类似的东西

lastN :: Int -> [a] -> [a]
lastN n xs = drop (length xs - n) xs

但是对于内置列表中的任何实现，您的性能都不会比O(length of list - n) 好。

您似乎正在尝试将 list 用于某些原本不能有效执行的操作。 使用Data.Sequence 或其他一些允许在列表末尾高效执行操作的列表实现。

---

编辑：

Davorak 的实现看起来是您可以从内置列表中获得的最有效的实现。但请记住，除了单个函数的运行时间之外，还有其他复杂的问题，比如它是否与其他函数融合得很好。

Daniel 的解决方案使用内置函数，具有与 Davorak 相同的复杂性，我认为与其他函数融合的机会更大。

Answer 3

不确定它是否非常快，但很容易：

lastR n xs = snd $ dropWhile (not . null . fst) $ zip (tails $ drop n xs) (tails xs)

Answer 4

请注意，无论您做什么，都需要遍历整个列表。也就是说，您可以比reverse (take n (reverse xs)) 做得更好，方法是先计算列表的长度，然后删除适当数量的元素：

lastN :: Int -> [a] -> [a]
lastN n xs = let m = length xs in drop (m-n) xs

Answer 5

这是对 Davorak 的第一个解决方案的简化：

-- dropLength bs = drop (length bs)
dropLength :: [b] -> [a] -> [a]
dropLength [] as = as
dropLength _ [] = []
dropLength (_ : bs) (_ : as) = dropLength bs as

lastR :: Int -> [a] -> [a]
lastR n as = dropLength (drop n as) as

当n <= length as，length (drop n as) = length as - n，所以dropLength (drop n as) as = drop (length (drop n as)) as = drop (length as - n) as，这是as的最后一个n元素。当n > length as，dropLength (drop n as) as = dropLength [] as = as，这是唯一明智的答案。

如果你想使用折叠，你可以写

dropLength :: [b] -> [a] -> [a]
dropLength = foldr go id
  where
     go _b _r [] = []
     go _b r (_a : as) = r as

这对lastR 没有任何影响，但在其他应用程序中它可以为您赢得一些列表融合。

Answer 6

简单的解决方案还不错。无论如何，算法都是 O(n)。

takeLastN n = reverse . take n . reverse

时间对比：

> length $ lastN 3000000 (replicate 10000000 "H") -- Davorak's solution #1
3000000
(0.88 secs, 560,065,232 bytes)
> length $ lastN' 3000000 (replicate 10000000 "H") -- Davorak's solution #2
3000000
(1.82 secs, 840,065,096 bytes)
> length $ lastN'' 3000000 (replicate 10000000 "H") -- Chris Taylor's solution
3000000
(0.50 secs, 560,067,680 bytes)
> length $ takeLastN 3000000 (replicate 10000000 "H") -- Simple solution
3000000
(0.81 secs, 1,040,064,928 bytes)

正如Joachim Breitner 在问题和评论中指出的那样，仍然存在内存问题。不比其他解决方案慢多少，这样的解决方案需要几乎两倍的内存。您可以在基准测试中看到这一点。

Answer 7

takeLast :: Int -> [a] -> [a]
takeLast n xs 
 | n < 1 = []
 | otherwise = let s = splitAt n xs in bla (fst s) (snd s)
 where 
  bla xs [] = xs
  bla (x:xs) (y:ys) = bla (xs ++ [y]) ys