scala leetcode 606 and fix scala btt、637

scala-leetcode/README.md

@@ -32,6 +32,7 @@ Leetcode Scala 实现
 * [二叉树的堂兄弟节点](./src/main/scala/io/github/dreamylost/Leetcode_993.scala)
 * [把二叉搜索树转换为累加树](./src/main/scala/io/github/dreamylost/Leetcode_538.scala)
 * [二叉树的坡度](./src/main/scala/io/github/dreamylost/Leetcode_563.scala)
+* [根据二叉树创建字符串](./src/main/scala/io/github/dreamylost/Leetcode_606.scala)
 
 ## 链表
 

scala-leetcode/src/main/scala/io/github/dreamylost/BTT.scala

@@ -4,7 +4,8 @@ package io.github.dreamylost
 
 import java.util.{ Queue => _ }
 
-import scala.collection.mutable
+import scala.collection.immutable.Queue
+import scala.collection.immutable.Stack
 
 /**
   * 二叉树的遍历
@@ -37,34 +38,36 @@ object BTT extends App {
   }
 
   //前，144. Binary Tree Preorder Traversal (Medium)
-  def preorderTraversal(root: TreeNode): mutable.Seq[Int] = {
-    val ret = mutable.Seq[Int]()
-    val stack = mutable.Stack[TreeNode]()
-    stack.push(root)
+  def preorderTraversal(root: TreeNode): Seq[Int] = {
+    var ret = Seq[Int]()
+    var stack = Stack[TreeNode]()
+    stack = stack.push(root)
     while (stack.nonEmpty) {
-      val node = stack.pop()
+      val (node, s) = stack.pop2
+      stack = s
       if (node != null) {
-        ret.:+(node.value)
-        stack.push(node.right) // 先右后左，保证左子树先遍历
-        stack.push(node.left)
+        ret = ret ++ Seq(node.value)
+        stack = stack.push(node.right) // 先右后左，保证左子树先遍历
+        stack = stack.push(node.left)
       }
     }
     ret
   }
 
   //中， 94. Binary Tree Inorder Traversal (Medium)
-  def inorderTraversal(root: TreeNode): mutable.Seq[Int] = {
-    val ret = mutable.Seq[Int]()
-    val stack = mutable.Stack[TreeNode]()
+  def inorderTraversal(root: TreeNode): Seq[Int] = {
+    var ret = Seq[Int]()
+    var stack = Stack[TreeNode]()
     if (root == null) return ret
     var cur = root
     while (cur != null || stack.nonEmpty) {
       while (cur != null) {
-        stack.push(cur)
+        stack = stack.push(cur)
         cur = cur.left
       }
-      val node = stack.pop()
-      ret.:+(node.value)
+      val (node, s) = stack.pop2
+      stack = s
+      ret = ret ++ Seq(node.value)
       cur = node.right
     }
     ret
@@ -75,34 +78,36 @@ object BTT extends App {
     * 前序遍历为 root -> left -> right，后序遍历为 left -> right -> root。可以修改前序遍历成为 root -> right -> left，那么这个顺序就和后序遍历正好相反。
     */
   //后，145. Binary Tree Postorder Traversal (Medium)
-  def postorderTraversal(root: TreeNode): mutable.Seq[Int] = {
-    val ret = mutable.Seq[Int]()
-    val stack = mutable.Stack[TreeNode]()
-    stack.push(root)
+  def postorderTraversal(root: TreeNode): Seq[Int] = {
+    var ret = Seq[Int]()
+    var stack = Stack[TreeNode]()
+    stack = stack.push(root)
     while (stack.nonEmpty) {
-      val node = stack.pop()
+      val (node, s) = stack.pop2
+      stack = s
       if (node != null) {
-        ret.:+(node.value)
-        stack.push(node.left) // 先右后左，保证左子树先遍历
-        stack.push(node.right)
+        ret = ret ++ Seq(node.value)
+        stack = stack.push(node.left) // 先右后左，保证左子树先遍历
+        stack = stack.push(node.right)
       }
     }
     ret.reverse
   }
 
   //层序
-  def levelTraverse(root: TreeNode): mutable.Seq[Int] = {
-    if (root == null) return mutable.Seq()
-    val list = mutable.Seq[Int]();
+  def levelTraverse(root: TreeNode): Seq[Int] = {
+    if (root == null) return Seq()
+    var list = Seq[Int]()
     //Scala的Seq将是Java的List，Scala的List将是Java的LinkedList。
-    val queue = mutable.Queue[TreeNode]() //层序遍历时保存结点的队列，可以省略new或者省略()
-    queue.enqueue(root)
+    var queue = Queue[TreeNode]() //层序遍历时保存结点的队列，可以省略new或者省略()
+    queue = queue.enqueue(root)
     //初始化
     while (queue.nonEmpty) {
-      val node = queue.dequeue
-      list.:+(node.value)
-      if (node.left != null) queue.enqueue(node.left)
-      if (node.right != null) queue.enqueue(node.right)
+      val (node, q) = queue.dequeue
+      queue = q
+      list = list ++ Seq(node.value)
+      if (node.left != null) queue = queue.enqueue(node.left)
+      if (node.right != null) queue = queue.enqueue(node.right)
     }
 
     list

scala-leetcode/src/main/scala/io/github/dreamylost/Leetcode_606.scala

+package io.github.dreamylost
+
+/**
+  * 606. 根据二叉树创建字符串
+  *
+ * 你需要采用前序遍历的方式，将一个二叉树转换成一个由括号和整数组成的字符串。
+  *
+ * 空节点则用一对空括号 "()" 表示。而且你需要省略所有不影响字符串与原始二叉树之间的一对一映射关系的空括号对。
+  *
+ * @author 梦境迷离 dreamylost
+  * @since 2020-06-14
+  * @version v1.0
+  */
+object Leetcode_606 extends App {
+  val ret = tree2str(TreeNodeData.treeData3_4())
+  println(ret)
+
+  /**
+    * 1128 ms,50.00%
+    * 66.4 MB,100.00%
+    *
+   * @param t
+    * @return
+    */
+  def tree2str(t: TreeNode): String = {
+    //输出前序遍历结果，其中子节点使用()包住，左边的空括号对不能省略，右边的需要省略，只处理左节点为空时的空括号对
+    var result = ""
+    if (t == null) return result
+    else if (t.left == null && t.right == null) return t.value.toString
+    else {
+      result = t.value.toString
+      if (t.left != null) {
+        result += s"(${tree2str(t.left)})"
+      } else result += "()"
+      if (t.right != null) {
+        result += s"(${tree2str(t.right)})"
+      }
+    }
+    result
+  }
+}

scala-leetcode/src/main/scala/io/github/dreamylost/Leetcode_637_Tree.scala

 package io.github.dreamylost
 
-import scala.collection.mutable.Queue
-
 /**
   * 层次遍历
   * 使用 BFS 进行层次遍历。不需要使用两个队列来分别存储当前层的节点和下一层的节点，因为在开始遍历一层的节点时，当前队列中的节点数就是当前层的节点数，只要控制遍历这么多节点数，就能保证这次遍历的都是当前层的节点。
   *
  *  637. Average of Levels in Binary Tree (Easy)
   * 一棵树每层节点的平均数
-  * @author 梦境迷离
+  *
+ * @author 梦境迷离
   * @time 2018年8月10日
   * @version v1.0
   */
 object Leetcode_637_Tree extends App {
 
-  def averageOfLevels(root: TreeNode): List[Double] = {
-    val ret = List()
+  val ret = averageOfLevels(TreeNodeData.treeData5_1())
+
+  ret.foreach(println)
+
+  /**
+    * 993类似
+    * 层序遍历时按层处理元素
+    *
+   * 848 ms,75.00%
+    * 53.8 MB,100.00%
+    *
+   * @param root
+    * @return
+    */
+  def averageOfLevels(root: TreeNode): Array[Double] = {
+    import scala.collection.immutable.Queue
+    var ret = Array[Double]()
     if (root == null) return ret
-    val queue = Queue[TreeNode]()
-    queue :+ root
-    while (!queue.isEmpty) {
-      var cnt = queue.size
-      var sum = 0
-      for (i <- 0 until cnt) {
-        val node = queue.dequeue()
+    var queue = Queue[TreeNode]()
+    queue = queue :+ root
+    while (queue.nonEmpty) {
+      val cnt = queue.size
+      var sum = 0d
+      for (_ <- 0 until cnt) {
+        val (node, q) = queue.dequeue
+        queue = q
         sum += node.value
-        if (node.left != null) queue :+ node.left //向尾部追加
-        if (node.right != null) queue :+ node.right
+        if (node.left != null) queue = queue.enqueue(node.left)
+        if (node.right != null) queue = queue.enqueue(node.right)
       }
-      ret.+:(sum / cnt)
+      ret = ret ++ Array[Double](sum / cnt.asInstanceOf[Double])
     }
     ret
   }