tree traversal

tree 遍历

中序，顺序，左中右

先序，先父节点，中左右

后序，先子节点，左右中

"use strict";

/**
 *
 * @author xgqfrms
 * @license MIT
 * @copyright xgqfrms
 * @created 2020-06-21
 * @modified
 *
 * @description
 * @augments
 * @example
 * @link
 *
 */

const log = console.log;

function BinarySearchTree () {
  var root = null;
  // 节点，构造函数
  function Node (key) {
    this.key = key;
    this.left = null;
    this.right = null;
  }
  // 闭包，私有方法
  function insertNode(root, node) {
    if(root.key > node.key) {
      // 左子树
      if (root.left === null) {
        root.left = node;
      } else {
        insertNode(root.left, node);
      }
    } else {
      // root.key <= node.key
      // 右子树
      if (root.right === null) {
        root.right = node;
      } else {
        insertNode(root.right, node);
      }
    }
  }
  this.insert = function(key) {
    var node = new Node(key);
    if(!root && root === null) {
      root = node;
    } else {
      insertNode(root, node);
    }
  }
  this.getRoot = function(callback) {
    if(root) {
      callback(root);
    }
  }
  var traversalNodeKey = function(type = `min`, node, callback) {
    if(node !== null) {
      switch (type) {
        case 'min':
          if(node.left) {
            traversalNodeKey(type, node.left, callback);
          } else {
            callback(node.key)
          }
          break;
        case 'max':
          if(node.right) {
            traversalNodeKey(type, node.right, callback);
          } else {
            callback(node.key)
          }
          break;
        default:
          break;
      }
    }
  }
  this.getMin = function(callback) {
    if(root) {
      traversalNodeKey(`min`, root, callback);
    }
  }
  this.getMax = function(callback) {
    if(root) {
      traversalNodeKey(`max`, root, callback);
    }
  }
  // 遍历 utils
  var traversalNode = function(type = `in`, node, callback) {
    if(node !== null) {
      switch (type) {
        case 'pre':
          // 中左右
          callback(node.key);
          traversalNode(node.left, callback);
          traversalNode(node.right, callback);
          break;
        case 'post':
          // 左右中
          traversalNode(node.left, callback);
          traversalNode(node.right, callback);
          callback(node.key);
          break;
        case 'in':
          default:
          // 左中右
          traversalNode(node.left, callback);
          callback(node.key);
          traversalNode(node.right, callback);
          break;
        // default:
        //   break;
      }
    }
  }
  // 中序遍历
  this.inOrderTraverse = function(callback) {
    if(root) {
      inOrderTraverseNode(root, callback);
      // traversalNode(`in`, root, callback);
    }
  }
  var inOrderTraverseNode = function(node, callback) {
    if(node !== null) {
      // 左中右
      inOrderTraverseNode(node.left, callback);
      callback(node.key);
      inOrderTraverseNode(node.right, callback);
    }
  }
  // 先序遍历
  this.preOrderTraverse = function(callback) {
    if(root) {
      preOrderTraverseNode(root, callback);
      // traversalNode(`pre`, root, callback);
    }
  }
  var preOrderTraverseNode = function(node, callback) {
    if(node !== null) {
      // 中左右
      callback(node.key);
      preOrderTraverseNode(node.left, callback)
      preOrderTraverseNode(node.right, callback)
    }
  }
  // 后序遍历
  this.postOrderTraverse = function(callback) {
    if(root) {
      postOrderTraverseNode(root, callback);
      // traversalNode(`post`, root, callback);
    }
  }
  var postOrderTraverseNode = function(node, callback) {
    if(node !== null) {
      // 左右中
      postOrderTraverseNode(node.left, callback);
      postOrderTraverseNode(node.right, callback);
      callback(node.key);
    }
  }
}

// export default BinarySearchTree;

// export {
//   BinarySearchTree,
// };

// test

const bst = new BinarySearchTree();

bst.insert(7)
bst.insert(8)
bst.insert(6)
bst.insert(9)
bst.insert(5)
bst.insert(10)
bst.insert(4)
bst.insert(11)
bst.insert(3)
bst.insert(12)
bst.insert(2)
bst.insert(13)
bst.insert(1)

var arr = [];
function print (key) {
  // log(`node.key`, key)
  arr.push(key);
  if(arr.length > 12) {
    log(`arr`, arr)
  }
}

// arr = [];
// bst.inOrderTraverse(print);

// arr = [];
// bst.preOrderTraverse(print);

// arr = [];
// bst.postOrderTraverse(print);

// bst.getRoot((root) => log(`root`, root));
// bst.getRoot((root) => log(`root`, JSON.stringify(root)));
// bst.getRoot((root) => log(`root`, JSON.parse(JSON.stringify(root))));

bst.getMin((min) => log(`min node`, min))
bst.getMax((max) => log(`max node`, max))

Binary tree

---

---

xgqfrms 2012-2020

www.cnblogs.com 发布文章使用：只允许注册用户才可以访问！

---