Refine kotlin code (#1241)

* style(kotlin): Improve kotlin codes readability.

* remove redundant quotes.

* style(kotlin): improve codes readability.

* style(kotlin): refine kotlin codes.

* Create kotlin.yml

* Create kotlin.yml

* Delete .github/workflows/kotlin

* Delete .github/workflows/main.yml

* Create kotlin.yml

* Update kotlin.yml

* Delete .github/workflows/kotlin.yml

* Create hello_world_workflow.main.kts

* Delete .github/workflows/hello_world_workflow.main.kts

* remove empty line

codes/kotlin/chapter_tree/array_binary_tree.kt

@@ -10,7 +10,8 @@ import utils.TreeNode
 import utils.printTree
 
 /* 数组表示下的二叉树类 */
-class ArrayBinaryTree(private val tree: List<Int?>) {
+/* 构造方法 */
+class ArrayBinaryTree(private val tree: MutableList<Int?>) {
     /* 列表容量 */
     fun size(): Int {
         return tree.size
@@ -39,11 +40,12 @@ class ArrayBinaryTree(private val tree: List<Int?>) {
     }
 
     /* 层序遍历 */
-    fun levelOrder(): List<Int?> {
-        val res = ArrayList<Int?>()
+    fun levelOrder(): MutableList<Int?> {
+        val res = mutableListOf<Int?>()
         // 直接遍历数组
         for (i in 0..<size()) {
-            if (value(i) != null) res.add(value(i))
+            if (value(i) != null)
+                res.add(value(i))
         }
         return res
     }
@@ -51,34 +53,38 @@ class ArrayBinaryTree(private val tree: List<Int?>) {
     /* 深度优先遍历 */
     fun dfs(i: Int, order: String, res: MutableList<Int?>) {
         // 若为空位，则返回
-        if (value(i) == null) return
+        if (value(i) == null)
+            return
         // 前序遍历
-        if ("pre" == order) res.add(value(i))
+        if ("pre" == order)
+            res.add(value(i))
         dfs(left(i), order, res)
         // 中序遍历
-        if ("in" == order) res.add(value(i))
+        if ("in" == order)
+            res.add(value(i))
         dfs(right(i), order, res)
         // 后序遍历
-        if ("post" == order) res.add(value(i))
+        if ("post" == order)
+            res.add(value(i))
     }
 
     /* 前序遍历 */
-    fun preOrder(): List<Int?> {
-        val res = ArrayList<Int?>()
+    fun preOrder(): MutableList<Int?> {
+        val res = mutableListOf<Int?>()
         dfs(0, "pre", res)
         return res
     }
 
     /* 中序遍历 */
-    fun inOrder(): List<Int?> {
-        val res = ArrayList<Int?>()
+    fun inOrder(): MutableList<Int?> {
+        val res = mutableListOf<Int?>()
         dfs(0, "in", res)
         return res
     }
 
     /* 后序遍历 */
-    fun postOrder(): List<Int?> {
-        val res = ArrayList<Int?>()
+    fun postOrder(): MutableList<Int?> {
+        val res = mutableListOf<Int?>()
         dfs(0, "post", res)
         return res
     }

codes/kotlin/chapter_tree/avl_tree.kt

@@ -23,7 +23,7 @@ class AVLTree {
     /* 更新节点高度 */
     private fun updateHeight(node: TreeNode?) {
         // 节点高度等于最高子树高度 + 1
-        node?.height = (max(height(node?.left).toDouble(), height(node?.right).toDouble()) + 1).toInt()
+        node?.height = max(height(node?.left), height(node?.right)) + 1
     }
 
     /* 获取平衡因子 */
@@ -103,10 +103,12 @@ class AVLTree {
             return TreeNode(value)
         var node = n
         /* 1. 查找插入位置并插入节点 */
-        if (value < node.value) node.left = insertHelper(node.left, value)
-        else if (value > node.value) node.right = insertHelper(node.right, value)
-        else return node // 重复节点不插入，直接返回
-
+        if (value < node.value)
+            node.left = insertHelper(node.left, value)
+        else if (value > node.value)
+            node.right = insertHelper(node.right, value)
+        else
+            return node // 重复节点不插入，直接返回
         updateHeight(node) // 更新节点高度
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
         node = rotate(node)
@@ -123,14 +125,22 @@ class AVLTree {
     private fun removeHelper(n: TreeNode?, value: Int): TreeNode? {
         var node = n ?: return null
         /* 1. 查找节点并删除 */
-        if (value < node.value) node.left = removeHelper(node.left, value)
-        else if (value > node.value) node.right = removeHelper(node.right, value)
+        if (value < node.value)
+            node.left = removeHelper(node.left, value)
+        else if (value > node.value)
+            node.right = removeHelper(node.right, value)
         else {
             if (node.left == null || node.right == null) {
-                val child = if (node.left != null) node.left else node.right
+                val child = if (node.left != null)
+                    node.left
+                else
+                    node.right
                 // 子节点数量 = 0 ，直接删除 node 并返回
-                if (child == null) return null
-                else node = child
+                if (child == null)
+                    return null
+                // 子节点数量 = 1 ，直接删除 node
+                else
+                    node = child
             } else {
                 // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
                 var temp = node.right
@@ -154,9 +164,14 @@ class AVLTree {
         // 循环查找，越过叶节点后跳出
         while (cur != null) {
             // 目标节点在 cur 的右子树中
-            cur = if (cur.value < value) cur.right!!
-            else (if (cur.value > value) cur.left
-            else break)!!
+            cur = if (cur.value < value)
+                cur.right!!
+            // 目标节点在 cur 的左子树中
+            else if (cur.value > value)
+                cur.left
+            // 找到目标节点，跳出循环
+            else
+                break
         }
         // 返回目标节点
         return cur

codes/kotlin/chapter_tree/binary_search_tree.kt

@@ -11,6 +11,7 @@ import utils.printTree
 
 /* 二叉搜索树 */
 class BinarySearchTree {
+    // 初始化空树
     private var root: TreeNode? = null
 
     /* 获取二叉树根节点 */
@@ -24,11 +25,14 @@ class BinarySearchTree {
         // 循环查找，越过叶节点后跳出
         while (cur != null) {
             // 目标节点在 cur 的右子树中
-            cur = if (cur.value < num) cur.right
+            cur = if (cur.value < num)
+                cur.right
             // 目标节点在 cur 的左子树中
-            else if (cur.value > num) cur.left
+            else if (cur.value > num)
+                cur.left
             // 找到目标节点，跳出循环
-            else break
+            else
+                break
         }
         // 返回目标节点
         return cur
@@ -46,45 +50,60 @@ class BinarySearchTree {
         // 循环查找，越过叶节点后跳出
         while (cur != null) {
             // 找到重复节点，直接返回
-            if (cur.value == num) return
+            if (cur.value == num)
+                return
             pre = cur
             // 插入位置在 cur 的右子树中
-            cur = if (cur.value < num) cur.right
+            cur = if (cur.value < num)
+                cur.right
             // 插入位置在 cur 的左子树中
-            else cur.left
+            else
+                cur.left
         }
         // 插入节点
         val node = TreeNode(num)
-        if (pre?.value!! < num) pre.right = node
-        else pre.left = node
+        if (pre?.value!! < num)
+            pre.right = node
+        else
+            pre.left = node
     }
 
     /* 删除节点 */
     fun remove(num: Int) {
         // 若树为空，直接提前返回
-        if (root == null) return
+        if (root == null)
+            return
         var cur = root
         var pre: TreeNode? = null
         // 循环查找，越过叶节点后跳出
         while (cur != null) {
             // 找到待删除节点，跳出循环
-            if (cur.value == num) break
+            if (cur.value == num)
+                break
             pre = cur
             // 待删除节点在 cur 的右子树中
-            cur = if (cur.value < num) cur.right
+            cur = if (cur.value < num)
+                cur.right
             // 待删除节点在 cur 的左子树中
-            else cur.left
+            else
+                cur.left
         }
         // 若无待删除节点，则直接返回
-        if (cur == null) return
+        if (cur == null)
+            return
         // 子节点数量 = 0 or 1
         if (cur.left == null || cur.right == null) {
             // 当子节点数量 = 0 / 1 时， child = null / 该子节点
-            val child = if (cur.left != null) cur.left else cur.right
+            val child = if (cur.left != null)
+                cur.left
+            else
+                cur.right
             // 删除节点 cur
             if (cur != root) {
-                if (pre!!.left == cur) pre.left = child
-                else pre.right = child
+                if (pre!!.left == cur)
+                    pre.left = child
+                else
+                    pre.right = child
             } else {
                 // 若删除节点为根节点，则重新指定根节点
                 root = child

codes/kotlin/chapter_tree/binary_tree_bfs.kt

@@ -16,13 +16,14 @@ fun levelOrder(root: TreeNode?): MutableList<Int> {
     val queue = LinkedList<TreeNode?>()
     queue.add(root)
     // 初始化一个列表，用于保存遍历序列
-    val list = ArrayList<Int>()
-    while (!queue.isEmpty()) {
-        val node = queue.poll() // 队列出队
-        list.add(node?.value!!) // 保存节点值
-        if (node.left != null) queue.offer(node.left) // 左子节点入队
-
-        if (node.right != null) queue.offer(node.right) // 右子节点入队
+    val list = mutableListOf<Int>()
+    while (queue.isNotEmpty()) {
+        val node = queue.poll()      // 队列出队
+        list.add(node?.value!!)      // 保存节点值
+        if (node.left != null)
+            queue.offer(node.left)   // 左子节点入队
+        if (node.right != null)
+            queue.offer(node.right)  // 右子节点入队
     }
     return list
 }
@@ -38,4 +39,4 @@ fun main() {
     /* 层序遍历 */
     val list = levelOrder(root)
     println("\n层序遍历的节点打印序列 = $list")
-}
+}

codes/kotlin/chapter_tree/binary_tree_dfs.kt

@@ -10,7 +10,7 @@ import utils.TreeNode
 import utils.printTree
 
 // 初始化列表，用于存储遍历序列
-var list = ArrayList<Int>()
+var list = mutableListOf<Int>()
 
 /* 前序遍历 */
 fun preOrder(root: TreeNode?) {