抽象数据类型

纯功能数据结构的效率

反向效率

• 考虑反转列表。下面是一个简单的解决方案：

• 颠倒 ::[一]->[一]颠倒[]=[]颠倒(x个:X轴)= 颠倒 X轴 ++[x个]

• 打了多少电话给

  ++

  使用反转列表n个元素？n个

• (++)::[一]->[一]->[一][]++ 年 = 年(x个:X轴)++ 年 = x个:(X轴 ++ 年)

• 要计算的工作量

  X轴++年

  ?O（运行）(n个),哪里n个=长度xs
• 要计算的总工作量

  颠倒 X轴

  ?O（运行）(n个²)

在GHCi中测试

• 使用：集合+s在GHCi中打开时间和内存统计。
  • ：集合+s 总额[1..10000]50005000（0.01秒，2633512字节）总和（反向[1..10000]）50005000（1.56秒，4455178368字节）
• 如何加速

  颠倒

  ?

更快的倒车

• 想法：使用累积参数

  • 颠倒 ::[一]->[一]颠倒 X轴 = revOnto（重新启动） X轴[]--revOnto xs-rs=反向xs++rsrevOnto（重新启动） ::[一]->[一]->[一]revOnto（重新启动）[]秒 = 秒
    revOnto（重新启动）(x个:X轴)秒 = revOnto（重新启动） X轴(x个:秒)

• helper函数

  revOnto（重新启动）

  • 将列表元素移动到累加参数上以相反的顺序出现。
  • 是尾部递归.

快速反转示例

• 颠倒[1,2,三]

  =

• 转速接通[1,2,三] []

  =

• revOnto（重新启动）[2,三]  [1]

  =

• revOnto（重新启动）[三]  [2,1]

  =

• revOnto（重新启动）[] [三,2,1]

  =

• [三,2,1]

• 要计算的总工作量

  颠倒 X轴

  现在？O（运行）(n个)

再次在GHCi中测试

• 总和（反向[1..10000]）50005000（0.01秒，3916656字节）总和（反向[1..1000000]）500000500000（0.89秒，386901184字节）
• 此版本可以反转1000000个元素比旧版本快了1000个元素！

数据结构

• 数据类型
  • 我们想要在程序中表示的东西的模型
• 数据结构
  • 一种特殊的数据存储方式
  • 什么是好的选择？这取决于我们想用数据。
  • 这可能是我们想要隐藏的实现细节。
• 今天的例子
  • 队列

什么是队列？

• 从后面进入，从前面离开
• 示例
  • 要打印的文件
  • 要发送的网络数据包
  • 要运行的进程
  • 要执行的任务
    

队列接口

数据 问 一                    --队列的类型
空的   :: 问 一              --空队列添加     :: 一 -> 问 一 -> 问 一  --在后面添加元素
栈空 :: 问 一 -> 布尔      --检查队列是否为空前面   :: 问 一 -> 一         --检查前部元件去除  :: 问 一 -> 问 一       --从前面移除元素

第一队列实现

• 一个简单的解决方案

• 数据 问 一 = 问[一]衍生(等式,显示)空的              = 问[]添加 x个(问 X轴)= 问(X轴++[x个])栈空(问 X轴)= 无效的 X轴
  前面(问(x个:X轴))= x个
  去除(问(x个:X轴))= 问 X轴

简单队列效率？

• 要计算的工作量

  • 添加 5(添加 4(添加 三(添加 2(添加 1 空的))))

• 看起来很眼熟？

新想法：使用两个列表

• 数据 问 一 = 问[一] [一]衍生 显示

• 我们可以快速添加新元素的“返回”列表（最后添加的元素位于第一位）。
• 我们可以快速删除元素的“前”列表（首先添加元素）。
• 使用高效

  颠倒

  将元素从后列表移到前列表当前面的列表变空时列出。

第一次尝试

• 空的                = 问[] []添加 x个(问 英尺 英国标准)= 问 英尺(x个:英国标准)栈空(问 英尺 英国标准)= 无效的 英尺 && 无效的 英国标准
  
  前面(问(（f）:英尺)英国标准)= x个
  前面(问[]英国标准)= 头(颠倒 英国标准)去除(问(（f）:英尺)英国标准)= 问 英尺 英国标准
  去除(问[]英国标准)= 问(尾(颠倒 英国标准)) []

• 如果我们允许前面的列表变空，我们可能会重复工作。。。
• 介绍不变量:永远不要在前面为空，后面为非空的情况下构建队列
• 通过使用智能构造函数.

智能构造函数

• 为了实现不变量，我们定义了智能构造函数

  智能Q

  并使用它，而不是直接使用构造函数

  问

  .

• 智能Q[]英国标准 = 问(颠倒 英国标准) []智能Q 英尺 英国标准 = 问 英尺 英国标准

操作

• 空的                      = 智能Q[] []添加 x个(问 前面 后面)= 智能Q 前面(x个:后面)栈空(问 前面 后面)= 无效的 前面
  前面(问(x个:_)_)= x个
  去除(问(x个:前面)后面)= 智能Q 前面 后面

• 使用

  智能Q

  强制执行不变量并简化代码。
  • 需要考虑的案例更少。

队列效率

• 什么时候需要做多少工作
  • 添加元素？O（1）
  • 删除元素？O（1）
  • 反转列表？O（1）
• 关键观察：
  • 每个添加的元素只从后向前移动一次。

队列相等

• 同一队列可以用多种方式表示，例如。

  • 问[1] [4,三,2]== 问[1,2] [4,三]== 问[1,2,三,4] []

• 但通过推导

  等式

  例如，将考虑这些队列不同。
• 所以我们定义了自己的

  等式

  实例：

  • 实例 等式 一 => 等式(问 一)哪里
      问题1 == 问题2 = 到列表 问题1 == 到列表 问题2
      
    到列表(问 前面 后面)= 前面 ++ 颠倒 后面

• 但是，什么类型的应用程序需要测试队列是否相等？也许这是不必要的？

模块和抽象数据类型

模块可用于隐藏实现细节

• 模块 排队(问,空的,添加,去除,前面,栈空)哪里
  
  数据 问 一 = 问[一] [一]衍生 显示
  
  空的 = 智能Q[] []-- ...-- ...

• 我们导出类型

  问

  但不是构造函数

  问

  • 以防止客户端破坏不变量。
• 我们不导出助手函数

  智能Q

  和

  到列表

  .
• 请参阅中的完整模块队列.hs.

关于导出列表

• 模块 排队(问,…)哪里
  • 这将导出类型

    问

    但不是它的构造者，
  • 所以

    问

    将是一个抽象类型在此模块之外。
• 模块 排队(问(..),…)哪里
  • 这将导出类型

    问

    以及所有的施工人员。

• 模块 排队 哪里

  • 这将导出所有内容（所有类型和函数）。

• 模块 排队()哪里

  • 不会导出任何函数或类型。（很少有用。）

正确性和测试

• 将简单实现用作参考.
  • 人们希望简单的意思是“明显正确”。
• 更复杂的实现应该与参考实现。