在Swift的世界里探索算法与压缩技术

在编码领域中，算法与压缩扮演着至关重要的角色，它们为我们处理和存储数据提供了有效的方法。在本文中，我们将深入探究《swift-algorithm-club》中的两大算法：行程长度压缩算法和霍夫曼编码。

行程长度压缩算法（RLE）专精于处理连续重复出现的值。它的运作原理很简单：它会扫描数据流，记录每个重复出现的字符或字节的次数。例如，如果数据流中有“AAABBBBCC”，RLE会将其压缩为“3A4B2C”。这种方法非常适合压缩包含大量重复元素的数据，如图像或音频文件。

另一方面，霍夫曼编码采用了一种更复杂的方法来压缩数据。它首先创建一个包含所有字符及其出现频率的频率表。然后，它基于频率构建一棵二叉树，每个字符都分配一个编码，编码长度与字符的频率成反比。例如，“A”出现得最频繁，将获得最短的编码。这种方法使我们能够更高效地压缩数据，因为它优先考虑出现频率更高的字符。

举个具体的例子，假设我们要压缩一个由以下字符组成的字符串：“AACDDEE”。使用霍夫曼编码，我们会创建如下二叉树：

         -
        / \
       A   C
      / \   \
     B   D   E

其中，“A”和“C”出现得最频繁，因此被分配为最短的编码（1位）。“B”、“D”和“E”被分配为更长的编码（2位）。使用这个编码，我们将字符串“AACDDEE”压缩为“111101100011”。

RLE和霍夫曼编码在Swift中的实现都非常简单。对于RLE，我们可以使用如下扩展：

extension String {
  func rle() -> String {
    var result = ""
    var lastChar = ""
    var count = 0
    for char in self {
      if char != lastChar {
        if count > 0 {
          result += "\(count)\(lastChar)"
        }
        lastChar = char
        count = 0
      }
      count += 1
    }
    if count > 0 {
      result += "\(count)\(lastChar)"
    }
    return result
  }
}

而对于霍夫曼编码，我们可以使用以下类：

class HuffmanNode: Comparable {
  var char: Character?
  var frequency: Int
  var left: HuffmanNode?
  var right: HuffmanNode?

  init(char: Character?, frequency: Int) {
    self.char = char
    self.frequency = frequency
  }

  static func < (lhs: HuffmanNode, rhs: HuffmanNode) -> Bool {
    return lhs.frequency < rhs.frequency
  }
}

class HuffmanTree {
  var root: HuffmanNode?

  func buildTree(frequencyTable: [Character: Int]) {
    var nodes = frequencyTable.map { HuffmanNode(char: $0.key, frequency: $0.value) }
    while nodes.count > 1 {
      nodes.sort()
      let leftNode = nodes.removeFirst()
      let rightNode = nodes.removeFirst()
      let parentNode = HuffmanNode(frequency: leftNode.frequency + rightNode.frequency)
      parentNode.left = leftNode
      parentNode.right = rightNode
      nodes.insert(parentNode, at: 0)
    }
    root = nodes.first
  }

  func getCodes() -> [Character: String] {
    var codes = [Character: String]()
    getCode(node: root, code: "")
    return codes

    func getCode(node: HuffmanNode?, code: String) {
      guard let node = node else {
        return
      }
      if let char = node.char {
        codes[char] = code
      } else {
        getCode(node: node.left, code: code + "0")
        getCode(node: node.right, code: code + "1")
      }
    }
  }

  func compress(string: String) -> String {
    var result = ""
    for char in string {
      if let code = codes[char] {
        result += code
      }
    }
    return result
  }

  var codes: [Character: String] = [:]
}

使用这些方法，我们可以轻松地将数据压缩为紧凑的格式。