二叉树-二叉排序树

二叉排序树

给定一个数组（7，3，10，12，5，1，9），要求能够高效地完成对数组的查询和添加。

二叉排序树，对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。
特别说明，如果有相同的值，可以将该节点 放在左子节点或右子节点。

二叉排序树的删除操作

二叉排序树的删除情况比较复杂，有下面三种情况需要进行考虑：
1）删除叶子节点（比如2，5，9，12）
2）删除只有一颗子树的节点（比如1）
3）删除有两颗子树的节点（比如：3，10）

1）删除叶子节点
删除的节点是叶子节点，即该节点下没有左右子节点。我们的二叉树是单向的，需要在删除时，找到删除节点的父节点。
1.先检索到要删除的节点。
1.1.没有找到，就退出。
2.如果我们找到要删除的节点，则需要找到该节点的父节点。
3.删除该节点。

2）删除只有一颗子树的节点（比如1）

3）删除有两颗子树的节点（比如：3，10）
比如：7
1.首先找到7元素的右子树的最小值，得到该值9
2.删除这个最小值9所在的节点
3.将元素7所在的节点的值改成9【target的中修改成最小值】

代码实现

package chapter18.binarytree

object BinarySortTree {
  def main(args: Array[String]): Unit = {
    val arr = Array(7, 3, 10, 12, 5, 1, 9, 2)
    //创建一颗二叉排序树
    val binarySortTree = new BinarySortTree
    for (i <- arr) {
      binarySortTree.add(new Node(i))
    }
    binarySortTree.infixOrder() // 1,2,3,5,7,9,10,12
    //    binarySortTree.delNode(2)
    //    binarySortTree.delNode(5)
    //    binarySortTree.delNode(9)
    //    binarySortTree.delNode(12)
    //    binarySortTree.delNode(7) // 有两个子节点的节点
    //    binarySortTree.delNode(3)
    //    binarySortTree.delNode(1) // 只有一个子节点的节点
    binarySortTree.delNode(10)
    println("--------------删除后---------------------")
    binarySortTree.infixOrder()
  }
}

/**
 * 定义节点
 *
 * @param value
 */
class Node(var value: Int) {
  var left: Node = null
  var right: Node = null

  /**
   * 查找某个节点，根据值
   *
   * @param value 数组元素值
   * @return 节点
   */
  def search(value: Int): Node = {
    //先判断当前节点是否为要删除的节点
    if (value == this.value) {
      return this
    } else if (value < this.value) {
      //向左递归查找
      if (this.left == null) {
        return null
      }
      //递归向左子树查找
      return this.left.search(value)
    } else {
      if (this.right == null) {
        return null
      }
      //递归向右子树查找
      return this.right.search(value)
    }
  }

  /**
   * 找某个节点的父节点
   *
   * @param value
   * @return
   */
  def searchParent(value: Int): Node = {
    //思路
    //1.先判断当前节点的左子节点或者右子节点是否是这个值
    if ((this.left != null && this.left.value == value) ||
      (this.right != null && this.right.value == value)) {
      return this
    } else {
      if (value < this.value && this.left != null) { //说明需要向左边递归查找
        return this.left.searchParent(value)
      } else if (value > this.value && this.right != null) { //说明需要向右边递归查找
        return this.right.searchParent(value)
      } else {
        return null
      }
    }
  }

  /**
   * 中序遍历
   */
  def infixOrder(): Unit = {
    //向左递归，输出左子树
    if (this.left != null) {
      this.left.infixOrder()
    }
    //先输出当前节点的值
    println(s"节点信息 value=${value} ")
    //向右递归，输出右子树
    if (this.right != null) {
      this.right.infixOrder()
    }
  }

  /**
   * 添加的方法
   *
   * @param node
   */
  def add(node: Node): Unit = {
    if (node == null) {
      //如果节点为空，返回
      return
    }
    //如果要插入的节点的值小于当前节点的值，则可以处理
    if (node.value < this.value) {
      if (this.left == null) {
        //说明该节点下无左子节点
        this.left = node
      } else {
        //递归进行插入
        this.left.add(node)
      }
    } else {
      //如果插入的节点的值不小于当前节点的值
      if (this.right == null) {
        this.right = node
      } else {
        //递归进行插入
        this.right.add(node)
      }
    }
  }


}

/**
 * 定义二叉排序树
 */
class BinarySortTree {
  var root: Node = null

  /**
   * 查找节点
   *
   * @param value
   * @return
   */
  def search(value: Int): Node = {
    if (root != null) {
      return root.search(value)
    } else {
      return null
    }
  }

  /**
   * 查找父节点
   *
   * @param value
   * @return
   */
  def searchParent(value: Int): Node = {
    if (root != null) {
      root.searchParent(value)
    } else {
      null
    }
  }

  /**
   * 删除某个子树的最小值的节点，并返回最小值
   *
   * @param node
   * @return
   */
  def delRightTreeMin(node: Node): Int = {
    var target = node
    //使用while循环找到右子树的最小值
    while (target.left != null) {
      target = target.left
    }
    val minValue = target.value
    //删除最小值对应的节点
    delNode(minValue)
    return minValue
  }

  /**
   * 删除节点
   *
   * @param value
   */
  def delNode(value: Int): Unit = {
    if (root == null) {
      //如果是空树，则不删
      return null
    } else {
      //先看一下有没有要删除的节点
      var targetNode = search(value)
      if (targetNode == null) {
        //没有要删除的节点，就直接返回
        return null
      }
      //查找targetNode的父节点
      var parentNode = searchParent(value)
      if (parentNode == null) {
        root = null
        return
      }
      if (targetNode.left == null && targetNode.right == null) {
        //targetNode 没有叶子节点
        if (parentNode.left != null && parentNode.left.value == value) {
          parentNode.left = null
        } else {
          //        if (parentNode != null && parentNode.right.value == value) {
          parentNode.right = null
        }
      } else if (targetNode.left != null && targetNode.right != null) {
        //targetNode 有两个叶子节点
        val value = delRightTreeMin(targetNode.right)
        //重置该值
        targetNode.value = value
      } else {
        //targetNode 有一个叶子节点
        //判断targetNode 是parentNode的左子节点还是右子节点
        if (targetNode.left != null) {
          //要删除的节点的左子节点不为空
          //判断targetNode是parentNode的左还是右
          if (parentNode.left.value == value) {
            parentNode.left = targetNode.left
          } else {
            parentNode.right = targetNode.left
          }
        } else {
          //判断targetNode 是parentNode的左还是右
          if (parentNode.left.value == value) {
            parentNode.left = targetNode.right
          } else {
            parentNode.right = targetNode.right
          }
        }

      }
    }
  }

  /**
   * 中序遍历
   */
  def infixOrder(): Unit = {
    if (root != null) {
      root.infixOrder()
    } else {
      println("当前二叉树为空，不能遍历")
    }
  }

  /**
   * 添加节点
   *
   * @param node
   */
  def add(node: Node): Unit = {
    if (root == null) {
      root = node
    } else {
      root.add(node)
    }
  }
}

运行结果