数据结构与算法之二叉树 ——in dart

用dart语言实现的二叉树，实现了插入、查找、删除，中序遍历、前序、后序遍历等功能。

 class BinaryTree<E extends Comparable> {
   Node<E> _root;
   int _nodeNumbers;

   BinaryTree() : _nodeNumbers = 0;

   factory BinaryTree.from(Iterable<E> elements) {
     var tree = BinaryTree<E>();
     for (var e in elements) tree.insert(e);
     return tree;
   }

   bool get isEmpty => _root == null;
   int get nodeNumbers => _nodeNumbers;

   void clear() {
     _root = null;
     _nodeNumbers = 0;
   }

   bool delete(E value) {
     var deleted = find(value);
     if (deleted == null) return false;
     _delete(deleted);
     _nodeNumbers--;
     return true;
   }

   Node<E> find(E value) {
     var current = _root;
     while (current != null) {
       var c = value.compareTo(current.value);
       if (c == 0) break;
       current = c < 0 ? current.leftChild : current.rightChild;
     }
     return current;
   }

   void insert(E value) {
     var inserted = Node(value);
     if (isEmpty) {
       _root = inserted;
     } else {
       var current = _root;
       while (current != null) {
         if (value.compareTo(current.value) <= 0) {
           if (current.leftChild == null) {
             current.leftChild = inserted;
             inserted.parent = current;
             break;
           } else {
             current = current.leftChild;
           }
         } else {
           if (current.rightChild == null) {
             current.rightChild = inserted;
             inserted.parent = current;
             break;
           } else {
             current = current.rightChild;
           }
         }
       }
     }
     _nodeNumbers++;
   }

   void traverse(void func(E value), [TraverseOrder order]) {
     _traverse(_root, order, func);
   }

   E get max {
     if (isEmpty) throw TreeEmptyException();
     var maxNode = _root;
     while (maxNode.rightChild != null) maxNode = maxNode.rightChild;
     return maxNode.value;
   }

   E get min {
     if (isEmpty) throw TreeEmptyException();
     return _minNode(_root).value;
   }

   Node<E> _minNode(Node<E> root) {
     var minNode = root;
     while (minNode.leftChild != null) minNode = minNode.leftChild;
     return minNode;
   }

   void _delete(Node<E> deleted) {
     var successor = _successor(deleted);
     if (successor != null) _delete(successor);
     if (deleted == _root) _root = successor;
     _replace(deleted, successor);
   }

   static void _replace<E>(Node<E> deleted, Node<E> successor) {
     if (deleted.parent != null) {
       if (deleted.parent.leftChild == deleted)
         deleted.parent.leftChild = successor;
       else
         deleted.parent.rightChild = successor;
     }

     if (successor != null) {
       successor.parent = deleted.parent;
       successor.leftChild = deleted.leftChild;
       successor.rightChild = deleted.rightChild;
       if (deleted.leftChild != null) deleted.leftChild.parent = successor;
       if (deleted.rightChild != null) deleted.rightChild.parent = successor;
     }
   }

   Node<E> _successor(Node<E> node) =>
       node.rightChild != null ? _minNode(node.rightChild) : node.leftChild;

   static void _traverse<E>(Node<E> root, TraverseOrder order, void func(E e)) {
     if (root == null) return;
     switch (order) {
       case TraverseOrder.preOrder:
         func(root.value);
         _traverse(root.leftChild, order, func);
         _traverse(root.rightChild, order, func);
         break;
       case TraverseOrder.postOrder:
         _traverse(root.leftChild, order, func);
         _traverse(root.rightChild, order, func);
         func(root.value);
         break;
       default:
         _traverse(root.leftChild, order, func);
         func(root.value);
         _traverse(root.rightChild, order, func);
     }
   }
 }

 enum TraverseOrder { preOrder, inOrder, postOrder }

 class Node<E> {
   E value;
   Node<E> parent, leftChild, rightChild;

   Node(this.value);
 }

 class TreeEmptyException implements Exception {
   const TreeEmptyException();
   String toString() => 'TreeEmptyException';
 }