function binaryTreeTraverse (inputArr = [], way = 'in') {
  let root = null

  function Node (key) {
    this.key = key
    this.left = null
    this.right = null
  }

  function insertNode (node, newNode) {
    if (newNode.key < node.key) {
      node.left === null ? (node.left = newNode) : (insertNode(node.left, newNode))
    } else {
      node.right === null ? (node.right = newNode) : (insertNode(node.right, newNode))
    }
  }

  function insert (item) {
    const newNode = new Node(item)
    if (root === null) {
      root = newNode
    } else {
      insertNode(root, newNode)
    }
  }

  inputArr.forEach(item => {
    insert(item)
  })
  inputArr.length = 0

  function pushEle (node) {
    if (node !== null) {
      if (way === 'pre') {
        inputArr.push(node.key)
        pushEle(node.left)
        pushEle(node.right)
      } else if (way === 'in') {
        pushEle(node.left)
        inputArr.push(node.key)
        pushEle(node.right)
      } else if (way === 'post') {
        pushEle(node.left)
        pushEle(node.right)
        inputArr.push(node.key)
      }
    }
  }

  function invertTree (root) {
    if (root === null){
        return root
    }
    const tmp = root.left
    root.left = root.right
    root.right = tmp
    if (root.left !== null){
      invertTree(root.left)
    }
    if (root.right !== null){
      invertTree(root.right)
    }
    return root
  }

  invertTree(root)
  pushEle(root)

  return inputArr
}
binaryTreeTraverse([8, 3, 10, 1, 6, 14, 4, 7, 13])










function BinaryTree () {
  let root = null

  function Node (key) {
    this.key = key
    this.left = null
    this.right = null
  }

  function insertNode (node, newNode) {
    if (newNode.key < node.key) {
      node.left === null ? (node.left = newNode) : (insertNode(node.left, newNode))
    } else {
      node.right === null ? (node.right = newNode) : (insertNode(node.right, newNode))
    }
  }

  this.insert = (key) => {
    const newNode = new Node(key)
    if (root === null) {
      root = newNode
    } else {
      insertNode(root, newNode)
    }
  }

  function preOrderTraverseNode (node, callback) {
    if (node !== null) {
      callback(node.key)
      preOrderTraverseNode(node.left, callback)
      preOrderTraverseNode(node.right, callback)
    }
  }
  function inOrderTraverseNode (node, callback) {
    if (node !== null) {
      callback(node.key)
      inOrderTraverseNode(node.left, callback)
      inOrderTraverseNode(node.right, callback)
    }
  }
  function postOrderTraverseNode (node, callback) {
    if (node !== null) {
      callback(node.key)
      postOrderTraverseNode(node.left, callback)
      postOrderTraverseNode(node.right, callback)
    }
  }

  this.preOrderTraverse = (callback) => {
    preOrderTraverseNode(root, callback)
  }
  this.inOrderTraverse = (callback) => {
    inOrderTraverseNode(root, callback)
  }
  this.postOrderTraverse = (callback) => {
    postOrderTraverseNode(root, callback)
  }
}

const arr = [8, 3, 10, 1, 6, 14, 4, 7, 13]
const cb = (...obj) => console.log(...obj)
const bT = new BinaryTree()
arr.forEach(item => bT.insert(item))
bT.preOrderTraverse(cb)
bT.inOrderTraverse(cb)
bT.postOrderTraverse(cb)