refactor code

leetcode/src/main/scala/io/github/dreamylost/DFS.scala

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