11-二叉树排序树-Scala实现

二叉排序树的创建、遍历、删除

package com.atguigu.datastructures.binarytree

/**
  * 二叉排序树的创建和遍历
  * 删除，1.删除叶子节点，因为二叉排序树是单向的，需要在删除时，找到删除节点的父节点
  *      2.先检索要删除节点，如果没有找到就退出；反之，找到该节点的父节点
  *      3.删除该节点
  */
//Array(7,3,10,12,5,1,9)
object BinarySortTreeDemo {
  def main(args: Array[String]): Unit = {
    val arr=Array(7,3,10)
    val binarySortTree = new BinarySortTree
    for (elem <- arr) {
      binarySortTree.add(new Node(elem))
    }
    binarySortTree.infixOrder()
    //删除
    binarySortTree.delNode(10)
    binarySortTree.delNode(3)
    println("删除后")
    binarySortTree.infixOrder()

  }

}

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

  //根据值来查找某个节点
  def search(value:Int):Node={
    //先判断当前节点是否是要删除的节点
    if(value == this.value){
      return this
    }else if(value < this.value){//向左递归查找
      if(this.left == null){
        return null
      }else{
        return this.left.search(value)
      }
    }else{
      if (this.right == null){
         null
      }else{//否则向右递归查找
        this.right.search(value)
      }
    }

  }



  //找某个节点的父节点
  def searchParent(value:Int):Node={
    //思路
    //1.先判断当前节点的左子节点或者右子节点是否是这个值
    if((this.left != null && this.left.value == value) ||
      (this.right != null && this.right.value == value)
    ){
       this
    }else{
      if (this.left != null && value < this.value){//说明要向左边去递归查找
          this.left.searchParent(value)
      }else if (this.right != null && value > this.value){//说明要向左边去递归查找
        this.right.searchParent(value)
      }else {
        null
      }
    }
  }
  //添加方法
  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)
      }
    }
  }
  def infixOrder(): Unit ={
    if (this.left != null){
      this.left.infixOrder()
    }
    printf("节点信息 no=%d \n",value)
    if (this.right != null){
      this.right.infixOrder()
    }
  }
}

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

  //删除某个右子树的最小值的节点，并返回最小值
  def delRightTreeMin(node: Node): Int ={
    var target = node
    //使用while循环，找到右子树的最小值
    while (target.left != null){
      target = target.left
    }
    val minValue = target.value
    delNode(minValue)
    minValue
  }
  //查找节点
  def search(value:Int):Node={
    if (root != null){
      root.search(value)
    }else{
      null
    }
  }
  //查找父节点
  def searchParent(value:Int):Node={
    if (root != null){
      root.searchParent(value)
    }else{
      null
    }
  }

  //删除节点
  //1.先考虑的是叶子节点
  def delNode(value:Int): Unit ={
    if (root == null){//如果是空树，就不删除
      null
    }
    //先看有没有要删除的节点
    var targetNode = search(value)
    if (targetNode == null){
      return
    }
    var parentNode = searchParent(value)
    if (parentNode==null){
      root = null
      return
    }
    //1.先考虑的是叶子节点
    if (targetNode.left == null && targetNode.right == null){
      //判断删除的节点parentNode的左子节点，还是右子节点
      if (parentNode.left != null && parentNode.left.value == value){
        parentNode.left = null
      }else{
        parentNode.right = null
      }
    }else if(targetNode.left != null && targetNode.right != null){
      val value: Int = delRightTreeMin(targetNode.right)
      targetNode.value = value
      //两个子节点
    }else{
      //targetNode只有一个子节点
      //判断是左子节点还是右子节点
      if (targetNode.left !=null){
        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 add(node: Node): Unit ={
    if (root == null){
      root = node
    }else{
      root.add(node)
    }
  }
  def infixOrder(): Unit ={
    if (root != null){
      root.infixOrder()
    }else{
      println("当前树为空")
    }
  }

}