二叉查找树（二叉搜索树or二叉排序树）（scala）代码实现-数据结构

二叉查找树：树的左子树的值小于根节点或父节点，右子数的值大于根节点或父节点，用scala实现二叉树的创建，插入，删除等操作

package com.dxt.tree

/**
  * 二叉查找树练习
  */
object Learn2Tree {

  class Node {
    var vlaue: Int = _
    var leftNode: Node = _
    var rightNode: Node = _
  }

  //定义树
  class Tree {
    var root: Node = _ //树的根节点

    def insertTree(root: Node, newNode: Node): Unit = {
      if (newNode.vlaue < root.vlaue) {
        //要判断一下是否有左子树
        if (root.leftNode == null) {
          root.leftNode = newNode
        } else {
          insertTree(root.leftNode, newNode)
        }
      } else {
        if (root.rightNode == null) {
          root.rightNode = newNode
        } else {
          insertTree(root.rightNode, newNode)
        }
      }
    }

    def insert(v: Int) {
      var newNode: Node = new Node //创建一个节点对象
      newNode.vlaue = v //给节点放一个值
      if (root == null) {
        //如果根节点什么都没有的时候，将新创建的Node赋给root,这样根节点就不为null
        root = newNode
      } else {
        //如果根节点不为null，就得判断要插入的数比跟的值小还是大，小的放左子树，大的放右子树
        insertTree(root, newNode) //插入的时候从跟节点判断，比根节点小的在左子树创建一个节点，否则在右侧创建一个节点
      }
    }

    //中序遍历可以做到排序功能（从小到大）
    def teavelTree(root: Node) {
      if (root != null) {
        teavelTree(root.leftNode)
        println("value= " + root.vlaue)
        teavelTree(root.rightNode)
      }
    }

    //遍历二叉查找数
    def travel() {
      teavelTree(root)
    }


    //查找二叉查找数的最小值
    def min(): Int = {
      var minTree = this.root
      while (!(minTree.leftNode == null)) {
        minTree = minTree.leftNode
      }
      minTree.vlaue
    }

    //查找二叉树中最大的值
  def max(): Unit = {
    var maxTree = this.root
    while (!(maxTree.rightNode == null)) {
      maxTree = maxTree.rightNode
    }
    maxTree.vlaue
  }


// 根据给定值查找.节点，根据根节点值判断，小于根节点的去左子树查找，大于根节点值的去右子数查找

    def find(va: Int): Node = {
      var tmpNode = this.root //判断根节点不为null
      while (tmpNode != null) {
        if (tmpNode.vlaue == va) {
          return tmpNode
        } else if (va < tmpNode.vlaue) {
          tmpNode = tmpNode.leftNode
        } else if (va > tmpNode.vlaue) {
          tmpNode = tmpNode.rightNode
        }
      }
      return tmpNode
    }

      /**
      * 查找最小值的节点
      * @param node
      * @return
      */
    def getMinValueNode(node: Node): Node = {
      if (node.leftNode == null) {
        return node
      } else {
        return getMinValueNode(node)
      }

    }

      /**
      * 删除节点
      * @param node
      * @param value
      * @return
      */
    def removeNode(node: Node, value: Int): Node = {

      if (node == null) {
        return null
      }
      if (node.vlaue == value) {
        //分为三种情况
        //①没有子节点的情况
        if (node.leftNode == null && node.rightNode == null) {
          return null
        }
        //②没有左子树
        if (node.leftNode == null) {
          return node.rightNode //那就指向右子数
        }
        //③没有右子树
        if (node.rightNode == null) {
          return node.leftNode //那就指向左子树
        }
        //④如果有两个子节点的，
        //如果待删除节点包含两个子节点，可以选择查找待删除节点左子树上的最大值或者查找其右子树上的最小值
        var tempNode = getMinValueNode(node.rightNode)
        node.vlaue = tempNode.vlaue
        node.rightNode = removeNode(node.rightNode, tempNode.vlaue)

        return node
      } else if (value < node.vlaue) {

        node.leftNode = removeNode(node.leftNode, value)
        return node.leftNode

      } else {
        node.rightNode = removeNode(node.rightNode, value)
        return node.rightNode

      }
    }
  }

  def main(args: Array[String]): Unit = {
    var tree = new Tree
    tree.insert(50)
    tree.insert(30)
    tree.insert(60)
    //tree.travel()
    println(tree.min())
  }
}

参考文章:https://www.jianshu.com/p/6a4b7f261e99