二叉树的遍历(Kotlin)

package com.colbert.binarytree

import com.sun.jmx.remote.internal.ArrayQueue
import java.util.*

class BinaryTree(var rootNode: TreeNode = BinaryTree.TreeNode(1, "A")) {

    class TreeNode {
        var index: Int
        var data: String
        var leftChild: TreeNode?
        var rightChild: TreeNode?

        constructor(index: Int, data: String) {
            this.index = index
            this.data = data
            this.leftChild = null
            this.rightChild = null
        }
    }

    /**
     * 构建二叉树
     *             A
     *       B          C
     *  D        E F         G
     */
    fun createBinaryTree() {
        var nodeB = TreeNode(2, "B")
        var nodeC = TreeNode(3, "C")
        var nodeD = TreeNode(4, "D")
        var nodeE = TreeNode(5, "E")
        var nodeF = TreeNode(6, "F")
        var nodeG = TreeNode(6, "G")
        rootNode.leftChild = nodeB;
        rootNode.rightChild = nodeC
        nodeB.leftChild = nodeD
        nodeB.rightChild = nodeE
        nodeC.leftChild = nodeF
        nodeC.rightChild = nodeG
    }

    /**
     * 树的高度
     */
    fun getHeight(): Int {
        return getHeight(rootNode);
    }

    fun getHeight(node: TreeNode?): Int {
        if (node == null) {
            return 0
        } else {
            return Math.max(getHeight(node?.leftChild), getHeight(node?.rightChild)) + 1
        }
    }

    /**
     * 树的节点数
     */
    fun getSize(): Int {
        return getSize(rootNode)
    }

    fun getSize(node: TreeNode?): Int {
        if (node == null) {
            return 0
        } else {
            // 父节点(1) + 左节点 + 右节点
            return getSize(node?.leftChild) + getSize(node?.rightChild) + 1
        }
    }

    /**
     * 前序遍历
     * 顺序：先遍历根节点，再遍历左子节点，最后遍历右子节点
     */
    fun preOrder() {
        preOrder(rootNode)
    }

    fun preOrder(node: TreeNode?) {
        if (node == null) return
        print(node?.data + " ")
        preOrder(node?.leftChild)
        preOrder(node?.rightChild)
    }

    /**
     * 前序遍历
     * 非迭代实现 （栈）
     */
    fun stackPreOrder() {
        if (rootNode == null) return
        var stack: Stack = Stack()
        stack.push(rootNode)
        do {
            var node: TreeNode = stack.pop()
            print(node.data + " ")
            if (node.rightChild != null) {
                stack.push(node.rightChild)
            }
            if (node.leftChild != null) {
                stack.push(node.leftChild)
            }
        } while (!stack.isEmpty())
    }

    /**
     * 中序遍历
     * 顺序：先遍历左子节点，再遍历根节点，最后遍历右子节点
     */
    fun midOrder() {
        midOrder(rootNode)
    }

    fun midOrder(node: TreeNode?) {
        if (node == null) return
        midOrder(node?.leftChild)
        print(node?.data + " ")
        midOrder(node?.rightChild)
    }

    /**
     * 中序遍历
     * 非迭代实现 （栈）
     */
    fun stackMidOrder() {
        if (rootNode == null) return
        var stack: Stack = Stack()
        var node: TreeNode? = rootNode
        while (node != null || !stack.isEmpty()) {
            while (node != null) {
                stack.push(node)
                node = node?.leftChild
            }
            node = stack.pop()
            print(node?.data + " ")
            node = node?.rightChild
        }
    }

    /**
     * 后序遍历
     * 顺序：先遍历左子节点，再遍历右子节点，最后遍历根节点
     */
    fun afterOrder() {
        afterOrder(rootNode)
    }

    fun afterOrder(node: TreeNode?) {
        if (node == null) return
        afterOrder(node?.leftChild)
        afterOrder(node?.rightChild)
        print(node?.data + " ")
    }

    /**
     * 后序遍历
     * 非迭代实现 （栈）
     */
    fun stackAfterOrder() {
        if (rootNode == null) return
        var node: TreeNode? = rootNode
        var stack: Stack = Stack()
        // 存放右节点是否被访问过
        var map = HashMap();
        while (node != null || stack.isNotEmpty()) {
            while (node != null) {
                stack.push(node)
                node = node?.leftChild
            }
            node = stack.peek()
            if (map.getOrDefault(node, false)) {
                // 如果右节点被访问过，就打印出来，并把它弹出栈
                print(node?.data + " ")
                map.remove(stack.pop())
                node = null
            } else {
                map.put(node, true)
                node = node?.rightChild
            }
        }
    }

    /**
     * 层序遍历 （队列）
     * 顺序：按层次依次遍历树的节点
     */
    fun queueLevelOrder() {
        if (rootNode == null) return
        var queue = ArrayDeque()
        queue.offer(rootNode)
        while (queue.isNotEmpty()) {
            // 将对头的元素弹出队列
            var node = queue.poll()
            print(node?.data + " ")
            if (node?.leftChild != null) {
                // 将左节点加入到对尾
                queue.offer(node?.leftChild)
            }
            if (node?.rightChild != null) {
                // 将右节点加入到对尾
                queue.offer(node?.rightChild)
            }
        }
    }
}

fun main(args: Array) {
    var tree = BinaryTree()
    tree.createBinaryTree()

    // 树的高度
    print("树的高度 " + tree.getHeight())
    // 树的节点数
    print("\n树的节点数 " + tree.getSize())
    // 前序遍历
    print("\n前序遍历 ")
    tree.preOrder()
    // 前序栈遍历
    print("\n前序栈遍历 ")
    tree.stackPreOrder()
    // 中序遍历
    print("\n中序遍历 ")
    tree.midOrder()
    // 中序栈遍历
    print("\n中序栈遍历 ")
    tree.stackMidOrder()
    // 后序遍历
    print("\n后序遍历 ")
    tree.afterOrder()
    print("\n后序栈遍历 ")
    tree.stackAfterOrder()
    // 层序遍历
    print("\n层序遍历 ")
    tree.queueLevelOrder()
}