Swift 二叉树的常用操作：掌握查找、插入与删除的关键

Swift 二叉树，又称二叉查找树（BST），是一种具有独特性质和广泛应用的非线性数据结构。BST 拥有简单而高效的结构，能够有效地存储和组织数据，使其查找、插入和删除等操作都能在对数时间内完成。本文将带领您深入浅出地理解 Swift 二叉树常用操作，掌握查找、插入和删除的关键步骤，成为二叉树操作的高手。

1. 查找：二叉树中的寻宝之旅

   查找是二叉树最基本的操作之一。它通过递归或迭代的方式，在二叉树中查找指定的值是否存在。

   1. 递归查找：

      func find(value: Int) -> Bool {
          if self.value == value {
              return true
          } else if value < self.value {
              return left?.find(value: value) ?? false
          } else {
              return right?.find(value: value) ?? false
          }
      }
      

   2. 迭代查找：

      func find(value: Int) -> Bool {
          var current = self
          while current != nil {
              if current!.value == value {
                  return true
              } else if value < current!.value {
                  current = current!.left
              } else {
                  current = current!.right
              }
          }
          return false
      }
      

2. 插入：在二叉树中安家落户

   插入是向二叉树中添加新值的常用操作。它按照二叉树的规则，将新值插入适当的位置，保持二叉树的性质。

   1. 递归插入：

      func insert(value: Int) {
          if self.value == value {
              return
          } else if value < self.value {
              if left == nil {
                  left = Node(value: value)
              } else {
                  left!.insert(value: value)
              }
          } else {
              if right == nil {
                  right = Node(value: value)
              } else {
                  right!.insert(value: value)
              }
          }
      }
      

   2. 迭代插入：

      func insert(value: Int) {
          var current = self
          while true {
              if current!.value == value {
                  return
              } else if value < current!.value {
                  if current!.left == nil {
                      current!.left = Node(value: value)
                      break
                  } else {
                      current = current!.left
                  }
              } else {
                  if current!.right == nil {
                      current!.right = Node(value: value)
                      break
                  } else {
                      current = current!.right
                  }
              }
          }
      }
      

3. 删除：从二叉树中抹去痕迹

   删除是从二叉树中移除指定值的常用操作。它需要考虑各种情况，以保持二叉树的性质。

   1. 递归删除：

      func delete(value: Int) {
          if self.value == value {
              // 若无子节点，直接删除
              if left == nil && right == nil {
                  return
              }
      
              // 若仅有一个子节点，直接替换
              if left != nil && right == nil {
                  self.value = left!.value
                  left = nil
                  return
              }
      
              if left == nil && right != nil {
                  self.value = right!.value
                  right = nil
                  return
              }
      
              // 若有两个子节点，找到右子树最小值替换
              var minNode = right
              while minNode!.left != nil {
                  minNode = minNode!.left
              }
              self.value = minNode!.value
              delete(value: minNode!.value)
              return
          } else if value < self.value {
              left?.delete(value: value)
          } else {
              right?.delete(value: value)
          }
      }
      

   2. 迭代删除：

      func delete(value: Int) {
          var current = self
          var parent: Node?
      
          while current != nil {
              if current!.value == value {
                  break
              } else if value < current!.value {
                  parent = current
                  current = current!.left
              } else {
                  parent = current
                  current = current!.right
              }
          }
      
          if current == nil {
              return
          }
      
          // 若无子节点，直接删除
          if current!.left == nil && current!.right == nil {
              if parent!.left === current {
                  parent!.left = nil
              } else {
                  parent!.right = nil
              }
              return
          }
      
          // 若仅有一个子节点，直接替换
          if current!.left != nil && current!.right == nil {
              if parent!.left === current {
                  parent!.left = current!.left
              } else {
                  parent!.right = current!.left
              }
              return
          }
      
          if current!.left == nil && current!.right != nil {
              if parent!.left === current {
                  parent!.left = current!.right
              } else {
                  parent!.right = current!.right
              }
              return
          }
      
          // 若有两个子节点，找到右子树最小值替换
          var minNode = current!.right
          while minNode!.left != nil {
              minNode = minNode!.left
          }
          current!.value = minNode!.value
          delete(value: minNode!.value)
          return
      }
      

通过本文的讲解，您已经掌握了 Swift 二叉树常用操作，包括查找、插入和删除。这些操作是二叉树的基本功能，也是理解二叉树的性质和应用的关键。希望这些知识能够帮助您在编程实践中更加熟练地使用二叉树。