数据结构系列之2-3-4树的插入、查找、删除和遍历完整版源代码实现与分析（dart语言实现）

　　本文属于原创，转载请注明来源。　　

　　在上一篇博文中，详细介绍了2-3树的操作（具体地址：https://www.cnblogs.com/outerspace/p/10861488.html），那么对于更多教科书上更为普遍的2-3-4树，在这里也给出 树的定义、节点的定义、插入、查找、删除和遍历等操作的源代码实现。

　　关于2-3-4树的文字定义，网上很多，可自行百度，这里不再重复论述。但看了很多博文，关于插入等操作的实现较多，基本上没有实现删除操作的。因此本博文给出完整版的2-3-4树的插入、删除、查找及遍历等源代码。

　　另，2-3-4树代码的实现，与2-3树非常类似，故关于代码的分析，请参考2-3树（https://www.cnblogs.com/outerspace/p/10861488.html）的介绍，这里仅给出简要说明。

　　如果节点允许的最大元素数量超过3个，非叶子节点最大孩子数量超过4个，就成了多叉树，后续有机会分享一下一个关于8叉树的实现。

　　本代码由dart语言实现，关于dart，一门类似Java、JavaScript的语言，也是现在比较流行的flutter的后台语言，有兴趣的同学可以去dart官网了解：

　　https://dart.dev

闲话少说，上代码。

 // 树的定义 2-3-4树
 class QuaternaryTree<E extends Comparable<E>> {
   QuaterNode<E> _root;
   int _elementsCount;

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

   QuaternaryTree() : _elementsCount = 0;

   int get elementsCount => _elementsCount;
   QuaterNode<E> get root => _root;

   // 计算树高
   int get height {
     var h = 0, c = root;
     while (c != null) {
       h++;
       c = c.isNotLeaf ? c.branches[0] : null;
     }
     return h;
   }

   bool get isEmpty => _root == null;

   bool contains(E value) => find(value) != null;

   // 查找树中是否存在某个值
   // 若找到，返回包含此值的树节点，否则返回null
   QuaterNode<E> find(E value) {
     var c = root;
     while (c != null) {
       var i = 0;
       while (i < c.size && c.items[i].compareTo(value) < 0) i++;
       if (i < c.size && c.items[i] == value) break;
       c = c.isNotLeaf ? c.branches[i] : null;
     }
     return c;
   }

   // 插入新的值，如果值已经存在，则不做任何操作
   // 插入始终在叶子节点进行
   void insert(E value) {
     var c = root, i = 0;
     while (c != null) {
       i = 0;
       while (i < c.size && c.items[i].compareTo(value) < 0) i++;
       if (i < c.size && c.items[i] == value) return;
       if (c.isLeaf) break;
       c = c.branches[i];
     }
     if (c != null) {
       c.items.insert(i, value);

       // 判断插入后是否需要修复
       if (c.isOverflow) _fixAfterIns(c);
     } else {
       _root = QuaterNode([value]);
     }
     _elementsCount++;
   }

   // 删除指定值
   bool delete(E value) {
     // 首先查找该值
     var d = find(value);
     // 若不存在，直接返回
     if (d == null) return false;

     // 查找该值在节点中的索引顺序
     var i = d.find(value);

     // 如果节点不是叶子节点，则用后继节点的值替代该值
     // 这样删除操作将转移为删除叶子节点的值
     if (d.isNotLeaf) {
       var s = _successor(d.branches[i + 1]);
       d.items[i] = s.items[0];
       d = s;
       i = 0;
     }
     d.items.removeAt(i);
     _elementsCount--;

     // 根据2-3-4树的定义，节点不能为空，因此判断删除后是否需要修复
     if (d.items.isEmpty) _fixAfterDel(d);
     return true;
   }

   // 遍历树
   void traverse(void func(List<E> items)) {
     if (!isEmpty) _traverse(_root, func);
   }

   // 插入修复
   // 注意，插入修复时，采用节点分裂的形式进行修复；
   // 分裂出来的新的父节点需要被上层节点吸收（如果存在上层节点的话）
   void _fixAfterIns(QuaterNode<E> c) {
     while (c != null && c.isOverflow) {
       var t = _split(c);
       c = t.parent != null ? _absorb(t) : null;
     }
   }

   // 节点分裂，由于分裂->吸收，可能会递归分裂；
   // 因此需要注意根节点的更新判断以及子节点的处理；
   QuaterNode<E> _split(QuaterNode<E> c) {
     var mid = c.size ~/ 2,
         l = QuaterNode._internal(c.items.sublist(0, mid)),
         nc = QuaterNode._internal(c.items.sublist(mid, mid + 1)),
         r = QuaterNode._internal(c.items.sublist(mid + 1));
     nc.branches.addAll([l, r]);
     l.parent = r.parent = nc;

     nc.parent = c.parent;
     if (c.parent != null) {
       var i = 0;
       while (c.parent.branches[i] != c) i++;
       c.parent.branches[i] = nc;
     } else {
       _root = nc;
     }
     if (c.isNotLeaf) {
       l.branches
         ..addAll(c.branches.getRange(0, mid + 1))
         ..forEach((b) => b.parent = l);
       r.branches
         ..addAll(c.branches.getRange(mid + 1, c.branches.length))
         ..forEach((b) => b.parent = r);
     }
     return nc;
   }

   // 上层节点吸收新分裂出来的节点，以保持树的平衡
   QuaterNode<E> _absorb(QuaterNode<E> c) {
     var i = 0, p = c.parent;
     while (p.branches[i] != c) i++;
     p.items.insertAll(i, c.items);
     p.branches.replaceRange(i, i + 1, c.branches);
     c.branches.forEach((b) => b.parent = p);
     return p;
   }

   // 查找后继节点
   QuaterNode<E> _successor(QuaterNode<E> p) {
     while (p.isNotLeaf) p = p.branches[0];
     return p;
   }

   // 删除修复
   void _fixAfterDel(QuaterNode<E> d) {
     if (d == root) {
       _root = null;
     } else {
       var ct = 0;
       while (d.size < (1 << ct + 1) - 1 && d.parent != null) {
         // 塌缩父节点
         _collapse(d.parent);
         d = d.parent;
         ct++;
       }

       // 如果塌缩到了树的根，则树高减1
       // if (d.size < (1 << ct + 1) - 1) ct--;
       if (d == root) ct--;

       // 修剪多余的值
       var rest = _prune(d, (1 << ct + 1) - 1);

       // 重新展开
       _expand(d, ct);

       // 将刚才修剪掉的多余的值重新插入树
       for (var e in rest) insert(e);
     }
   }

   // 树的塌缩函数，注意递归塌缩
   void _collapse(QuaterNode<E> p) {
     if (p.isLeaf) return;
     for (var i = p.branches.length - 1; i >= 0; i--) {
       _collapse(p.branches[i]);
       p.items.insertAll(i, p.branches[i].items);
     }
     p.branches.clear();
   }

   // 修剪，保留满足展开为满二叉树的最小数量的值
   List<E> _prune(QuaterNode<E> d, int least) {
     var t = d.size ~/ least, rest = <E>[];
     if (t < 2) {
       rest.addAll(d.items.getRange(least, d.size));
       d.items.removeRange(least, d.size);
     } else {
       // 跳跃修剪，以保证二次插入时分裂的次数较少
       var list = <E>[];
       for (var i = 0; i < d.size; i++) {
         if (i % t == 0 && list.length < least)
           list.add(d.items[i]);
         else
           rest.add(d.items[i]);
       }
       d.items = list;
     }
     _elementsCount -= rest.length;
     return rest;
   }

   // 递归展开修剪后的节点，ct代表展开的层数或高度
   void _expand(QuaterNode<E> p, int ct) {
     if (ct == 0) return;
     p = _split(p);
     for (var b in p.branches) _expand(b, ct - 1);
   }

   void _traverse(QuaterNode<E> r, void f(List<E> items)) {
     f(r.items);
     for (var b in r.branches) _traverse(b, f);
   }
 }

 class QuaterNode<E extends Comparable<E>> {
   static final int capacity = 3;
   List<E> items;
   List<QuaterNode<E>> branches;
   QuaterNode<E> parent;

   factory QuaterNode(List<E> elements) {
     if (elements.length > capacity) throw StateError('too many elements.');
     return QuaterNode._internal(elements);
   }

   QuaterNode._internal(List<E> elements)
       : items = [],
         branches = [] {
     items.addAll(elements);
   }

   int get size => items.length;
   bool get isOverflow => size > capacity;
   bool get isLeaf => branches.isEmpty;
   bool get isNotLeaf => !isLeaf;

   bool contains(E value) => items.contains(value);
   int find(E value) => items.indexOf(value);

   String toString() => items.toString();
 }

-end-