Question

我正在阅读Chris Okasaki撰写的Purely Functional Data Structures。

在第6章中，本书向我们介绍了懒惰的评估，我比较了两个版本

(*
https://github.com/mmottl/pure-fun/blob/master/chp5.ml#L47
*)
module BatchedQueue : QUEUE = struct
  type 'a queue = 'a list * 'a list

  let empty = [], []
  let is_empty (f, _) = f = []

  let checkf (f, r as q) = if f = [] then List.rev r, f else q

  let snoc (f, r) x = checkf (f, x :: r)
  let head = function [], _ -> raise Empty | x :: _, _ -> x
  let tail = function [], _ -> raise Empty | _ :: f, r -> checkf (f, r)
end

懒惰版本将是：

(*
https://github.com/mmottl/pure-fun/blob/master/chp6.ml#L128
*)
module BankersQueue : QUEUE = struct
  type 'a queue = int * 'a stream * int * 'a stream

  let empty = 0, lazy Nil, 0, lazy Nil
  let is_empty (lenf, _, _, _) = lenf = 0

  let check (lenf, f, lenr, r as q) =
    if lenr <= lenf then q
    else (lenf + lenr, f ++ reverse r, 0, lazy Nil)

  let snoc (lenf, f, lenr, r) x =
    check (lenf, f, lenr + 1, lazy (Cons (x, r)))

  let head = function
    | _, lazy Nil, _, _ -> raise Empty
    | _, lazy (Cons (x, _)), _, _ -> x

  let tail = function
    | _, lazy Nil, _, _ -> raise Empty
    | lenf, lazy (Cons (_, f')), lenr, r -> check (lenf - 1, f', lenr, r)
end

这两个版本非常相似，check函数都需要反转列表，理论上是O（n）。

似乎两个版本都具有相同的时间复杂度，我想知道在队列数据结构中使用延迟评估的优势是什么？

Answer 1

check函数的懒惰版本（因此snoc）实际上是O（1），因为它使用延迟操作执行反向，即(++)和reverse是都很懒。这是给予信用的地方。您在head或tail时开始付款。此外，由于隐藏的可变性（并且懒惰实际上是受限制的可变性的变体），即使您有不同的未来，您也只需支付一次此信用。银行家队列（以及批处理队列）上有一个非常有趣的blog post可以帮助您理解为什么这会产生差异。

在队列数据结构中使用延迟评估有什么好处？

1 个答案: