多路查找树

多路查找树（Multway Search Tree）是一种高级的树形数据结构，它
允许每个节点有多个子节点（通常大于等于2）。多路查找树的每个节点
可以存储多个关键字和对应的值。

分类

2-3树（2-3 Tree）：
2-3树是一种最简单的多路查找树，每个节点可以存储1个或2个关键字，
并有2个或3个子节点。
2-3树的特点是所有叶子节点都在同一层，且根节点到每个叶子节点的
路径长度相等，保持树的平衡性。

B-树（B-tree）：
B-树是一种平衡的多路查找树，每个节点可以存储多个关键字，并有相
应数量的子节点。
B-树的特点是节点的关键字按照升序排列，具有高度平衡的特性，主要
用于在磁盘等外部存储设备中高效存储和检索数据。

B+树（B+ tree）：
B+树是B-树的一种变种，在B-树的基础上做了一些优化，特别适合于范
围查询和顺序访问。
B+树的特点是只有叶子节点存储了真实数据，而内部节点仅用于索引，
叶子节点通过指针连接形成一个链表，方便范围查询。

B树（B-tree）：
B*树也是B-树的一种变种，与B+树类似，它在B-树的基础上做了一些改
进。
B*树通过在非叶子节点中存储部分关键字，扩大了节点的使用率，减少
了磁盘访问次数，并提高了空间和时间的效率。

Trie树（字典树或前缀树）：
Trie树是一种特殊的多路查找树，在处理字符串和前缀匹配的情况下非
常有用。
Trie树的特点是每个节点代表一个字符，从根节点到叶子节点的路径可
以表示一个完整的字符串。

除此以外，还有如2-3-4树、2-3-4-树、B*+树等。每种多路查找树在
平衡性、存储结构、查询性能等方面可能有所不同，选择合适的多路查
找树取决于应用需求和数据特点。对于大规模的外部存储数据，B-树和
B+树是常见的选择；对于高效的字符串匹配和前缀查询，Trie树是一种
有效的数据结构。

详细介绍

2-3树（2-3 Tree）

2-3树是一种平衡的多路查找树，每个节点可以存储1个或2个关键字，并有2个
或3个子节点。以下是关于2-3树的详细介绍：

结构特点：

2-3树由节点组成，每个节点可以存储1个或2个关键字，这些关键字按升序排列。
每个节点有2个或3个子节点，对应于存储的关键字个数。
所有叶子节点都在同一层，且根节点到每个叶子节点的路径长度相等，保持树的
平衡性。

插入操作：

1、当要插入一个关键字时，从根节点开始，判断关键字应插入的位置。
2、如果节点已满（即已有两个关键字），则需要进行节点分裂操作。将中间较
	大的关键字移动到上一层的父节点，并将两个剩余的关键字分别创建为新的
	子节点。
3、如果节点还没有满，则直接将关键字插入到正确的位置。

删除操作：

当要删除一个关键字时，从根节点开始，找到包含该关键字的节点。
	如果该节点是叶子节点，直接删除关键字即可。如果该节点是内部节点，有
		几种情况需要处理：
	如果该节点有2个关键字，则可以直接删除关键字，不需要做其他操作。
	如果该节点有1个关键字：
	如果其兄弟节点有2个关键字，则可以借用兄弟节点的一个关键字，并进行
		相关的调整。
	如果其兄弟节点也只有1个关键字，则需要进行合并操作，将关键字和子节
		点合并到一起。

查询操作：

2-3树的查询操作与二叉查找树类似，从根节点开始，根据关键字的大小比较，
向左或向右子节点递归查询，直到找到匹配的关键字或遇到叶子节点。

强调

2-3树的特点在于其每个节点可以存储多个关键字，这样可以减少树的高度，提
供更高效的搜索和插入操作。它保持了树的平衡性，且所有叶子节点都在同一层，
这样可以保证较为平衡的查询性能。然而，2-3树的实现和维护操作较为复杂，
导致其并不常用，更常见的是其变种B-树和B+树，它们在2-3树的基础上进行了
一些优化和改进。

Java代码实现

// 2-3树的节点类
class Node {
    private int[] keys;  // 节点的关键字
    private Node[] children;  // 子节点数组
    private int size;  // 节点包含的关键字数量
    private boolean isLeaf;  // 是否为叶子节点

    public Node(boolean isLeaf) {
        this.keys = new int[3];
        this.children = new Node[4];
        this.size = 0;
        this.isLeaf = isLeaf;
    }

    // 从节点中查找关键字的位置
    public int findKey(int key) {
        for (int i = 0; i < size; i++) {
            if (keys[i] == key) {
                return i;
            } else if (keys[i] > key) {
                return -1;
            }
        }
        return -1;
    }

    // 在节点中插入关键字
    public void insertKey(int key) {
        if (size == 0) {
            keys[0] = key;
            size++;
        } else {
            int i = size - 1;
            while (i >= 0 && keys[i] > key) {
                keys[i + 1] = keys[i];
                i--;
            }
            keys[i + 1] = key;
            size++;
        }
    }

    // 在节点中删除关键字
    public void deleteKey(int key) {
        int index = findKey(key);
        if (index != -1) {
            for (int i = index; i < size - 1; i++) {
                keys[i] = keys[i + 1];
            }
            size--;
        }
    }

    // 获取节点的关键字数量
    public int getSize() {
        return size;
    }

    // 判断节点是否为叶子节点
    public boolean isLeaf() {
        return isLeaf;
    }

    // 获取节点指定位置的子节点
    public Node getChild(int index) {
        return children[index];
    }

    // 设置节点指定位置的子节点
    public void setChild(int index, Node child) {
        children[index] = child;
    }
}

// 2-3树类
class TwoThreeTree {
    private Node root;

    public TwoThreeTree() {
        root = null;
    }

    // 在2-3树中插入关键字
    public void insert(int key) {
        if (root == null) {
            root = new Node(true);
            root.insertKey(key);
        } else {
            Node newNode = insertKey(root, key);
            if (newNode != null) {
                Node oldRoot = root;
                root = new Node(false);
                root.setChild(0, oldRoot);
                root.setChild(1, newNode);
                root.insertKey(newNode.keys[0]);
                root.insertKey(oldRoot.keys[0]);
            }
        }
    }

    // 在给定的节点中插入关键字
    private Node insertKey(Node node, int key) {
        if (node.isLeaf()) {
            node.insertKey(key);
            if (node.getSize() > 2) {
                return splitLeaf(node);
            }
        } else {
            int i = node.getSize() - 1;
            while (i >= 0 && key < node.getChild(i).keys[0]) {
                i--;
            }
            Node newNode = insertKey(node.getChild(i + 1), key);
            if (newNode != null) {
                node.insertKey(newNode.keys[0]);
	}

B-树（B-tree）

B-树（B-tree）是一种平衡的多路查找树，广泛应用于在磁盘等外部存储设备中
高效地存储和检索大量数据。以下是关于B-树的详细介绍：

结构特点：

B-树由节点组成，每个节点可以存储多个
关键字，这些关键字按升序排列。
B-树的特点是节点的关键字按升序排列，具有高度平衡的特性。
每个节点通常有多个子节点，最多可以拥有m个子节点，其中m称为B-树的阶数。

插入操作：

1、当要插入一个关键字时，从根节点开始，判断关键字应插入的位置。
2、如果节点已满，则需要进行节点分裂操作。将中间位置的关键字提升为父节
	点，并将节点分裂为两个节点，将剩余的关键字均匀分配到这两个节点中。
3、如果要插入的节点还没有满，则直接将关键字插入到合适的位置。

删除操作：

1、当要删除一个关键字时，从根节点开始，找到包含该关键字的节点。
2、如果该节点是叶子节点，直接删除关键字即可。如果该节点是内部节点，需
	要找到其前驱或后继关键字来替代删除的关键字。
3、在删除操作后，如果节点中的关键字数量过少，则需要进行节点合并或者从
	兄弟节点中借用关键字来保持树的平衡。

查询操作：

B-树的查询操作与二叉查找树类似，从根节点开始，根据关键字的大小比较，
向左或向右子节点递归查询，直到找到匹配的关键字或遇到叶子节点。

强调

B-树适用于大规模数据存储和查询的场景，尤其是需要在外部存储设备上进行操
作的情况。B-树的高度平衡保证了较为均衡的查询性能，因为从根节点到叶子节
点的路径长度相等或差别不大。B-树的阶数m可以根据具体应用和硬件限制来选
择，通常情况下，较大的阶数有助于减少磁盘访问的次数，提高效率。

B-树的变种B+树在B-树的基础上做了一些优化，将所有数据存储在叶子节点中，
使得范围查询和顺序访问更加高效。因此，在现代数据库系统和文件系统中，
B+树更加常见和广泛应用。

代码实现

import java.util.ArrayList;
import java.util.List;

class BMinusTreeNode {
    public boolean isLeaf; // 是否是叶子节点
    public List<Integer> keys; // 节点中存储的关键字
    public List<BMinusTreeNode> children; // 节点的子节点

    public BMinusTreeNode() {
        keys = new ArrayList<>();
        children = new ArrayList<>();
    }
}

class BMinusTree {
    private BMinusTreeNode root;
    private int t; // B-树的阶数

    public BMinusTree(int degree) {
        root = new BMinusTreeNode();
        root.isLeaf = true;
        t = degree;
    }

    public void insert(int key) {
        // 根节点满了就分裂
        if (root.keys.size() == (2 * t)) {
            BMinusTreeNode newRoot = new BMinusTreeNode();
            newRoot.children.add(root);
            splitChild(newRoot, 0, root);
            root = newRoot;
        }
        insertNonFull(root, key);
    }

    private void insertNonFull(BMinusTreeNode node, int key) {
        int index = node.keys.size() - 1;
        if (node.isLeaf) {
            while (index >= 0 && node.keys.get(index) > key) {
                index--;
            }
            node.keys.add(index + 1, key);
        } else {
            while (index >= 0 && node.keys.get(index) > key) {
                index--;
            }
            index++;
            if (node.children.get(index).keys.size() == (2 * t)) {
                splitChild(node, index, node.children.get(index));
                if (node.keys.get(index) < key) {
                    index++;
                }
            }
            insertNonFull(node.children.get(index), key);
        }
    }

    private void splitChild(BMinusTreeNode parent, int index, BMinusTreeNode node) {
        BMinusTreeNode newNode = new BMinusTreeNode();
        newNode.isLeaf = node.isLeaf;
        parent.keys.add(index, node.keys.get(t - 1));
        parent.children.add(index + 1, newNode);
        for (int i = t; i < 2 * t - 1; i++) {
            newNode.keys.add(node.keys.get(i));
        }
        if (!node.isLeaf) {
            for (int i = t; i < 2 * t; i++) {
                newNode.children.add(node.children.get(i));
            }
        }
        for (int i = 2 * t - 2; i >= t - 1; i--) {
            node.keys.remove(i);
        }
        if (!node.isLeaf) {
            for (int i = 2 * t - 1; i >= t; i--) {
                node.children.remove(i);
            }
        }
    }

B+树（B+tree）

B+树（B+ tree）是B-树的一种变种，特别适用于范围查询和顺序访问。

结构特点：

B+树与B-树类似，由节点组成，每个节点可以存储多个关键字，这些关键字按升
序排列。

B+树的特点是只有叶子节点存储了真实数据，而内部节点仅用于索引。叶子节点
通过指针连接形成一个链表，方便范围查询和顺序访问。

内部节点特点：

内部节点存储关键字和指向子节点的指针。
内部节点的关键字按升序排列，用于指示范围查询的起点。
内部节点的指针指向比关键字更大的子节点。

叶子节点特点：

叶子节点存储真实数据和指向下一个叶子节点的指针。
叶子节点的关键字按升序排列，支持范围查询和顺序访问。
所有叶子节点通过指针连接成一个链表，便于范围查询和顺序访问。

插入操作：

当要插入一个关键字时，从根节点开始，找到合适的叶子节点。
如果叶子节点已满，则需要进行节点分裂操作。将中间位置的关键字提升到父节
点，并将两个剩余的部分分别创建为新的叶子节点。
如果叶子节点还没有满，则直接将关键字插入到合适的位置。

删除操作：

当要删除一个关键字时，从根节点开始，找到包含该关键字的叶子节点。
直接删除叶子节点中的关键字，并更新链表指针。
删除操作后，如果叶子节点的关键字个数过少，则需要从兄弟节点借用关键字或
进行节点合并。

查询操作：

B+树的查询操作与B-树类似，从根节点开始，根据关键字的大小比较，向左或向
	右子节点递归查询，直到找到匹配的关键字或遇到叶子节点。
对于范围查询和顺序访问，可以从叶子节点开始，沿着链表进行遍历。

强调

B+树的特点在于只有叶子节点存储真实数据，这样使得范围查询和顺序访问更加
高效，因为数据在叶子节点上连续存储，读取连续的数据块比随机读取更快。而
内部节点仅存储索引信息，可以容纳更多的索引，提高了查询效率。B+树的实现
适用于需要高效地处理大量数据的数据库和文件系统，能够提供较高的查询性能
和存储效率。

代码实现

import java.util.ArrayList;
import java.util.List;

class BPlusTreeNode {
    public boolean isLeaf;
    public List<Integer> keys;
    public List<Object> values;
    public List<BPlusTreeNode> children;
    public BPlusTreeNode next;

    public BPlusTreeNode() {
        isLeaf = false;
        keys = new ArrayList<>();
        values = new ArrayList<>();
        children = new ArrayList<>();
        next = null;
    }
}

class BPlusTree {
    private BPlusTreeNode root;
    private int m;

    public BPlusTree(int m) {
        root = new BPlusTreeNode();
        root.isLeaf = true;
        this.m = m;
    }

    // 插入操作
    public void insert(int key, Object value) {
        if (root.keys.size() == m) {
            BPlusTreeNode newRoot = new BPlusTreeNode();
            newRoot.children.add(root);
            splitChild(newRoot, 0, root);
            root = newRoot;
        }
        insertNonFull(root, key, value);
    }

    // 非满子节点插入操作
    private void insertNonFull(BPlusTreeNode node, int key, Object value) {
        int index = node.keys.size() - 1;
        if (node.isLeaf) {
            while (index >= 0 && node.keys.get(index) > key) {
                index--;
            }
            node.keys.add(index + 1, key);
            node.values.add(index + 1, value);
            node.next = node.next;
        } else {
            while (index >= 0 && node.keys.get(index) > key) {
                index--;
            }
            index++;
            if (node.children.get(index).keys.size() == m) {
                splitChild(node, index, node.children.get(index));
                if (node.keys.get(index) < key) {
                    index++;
                }
            }
            insertNonFull(node.children.get(index), key, value);
        }
    }

    // 分裂满子节点
    private void splitChild(BPlusTreeNode parent, int index, BPlusTreeNode node) {
        BPlusTreeNode newNode = new BPlusTreeNode();
        newNode.isLeaf = node.isLeaf;
        parent.keys.add(index, node.keys.get(m / 2));
        parent.children.add(index + 1, newNode);

        newNode.keys.addAll(node.keys.subList((m / 2) + 1, m));
        newNode.values.addAll(node.values.subList((m / 2) + 1, m));
        
        if (!node.isLeaf) {
            newNode.children.addAll(node.children.subList((m / 2) + 1, m + 1));
            node.children.subList((m / 2) + 1, m + 1).clear();
        } else {
            newNode.next = node.next;
            node.next = newNode;
        }

        node.keys.subList(m / 2, m).clear();
        node.values.subList(m / 2, m).clear();
    }

    // 搜索操作
    public List<Object> search(int key) {
        return search(root, key);
    }

    private List<Object> search(BPlusTreeNode node, int key) {
        int index = 0;
        while (index < node.keys.size() && key > node.keys.get(index)) {
            index++;
        }
        if (index < node.keys.size() && key == node.keys.get(index)) {
            return node.values.get(index);
        } else if (node.isLeaf) {
            return null;
        } else {
            return search(node.children.get(index), key);
        }
    }
}

B树（B-tree）

B树（B-tree）是一种平衡的多路查找树，主要用于在磁盘等外部存储设备中高
效地存储和检索大量数据。以下是关于B树的详细介绍：

结构特点：

B树由节点组成，每个节点可以存储多个关键字，这些关键字按升序排列。
B树的特点是节点的关键字按升序排列，具有高度平衡的特性。
每个节点通常有多个子节点，最多可以拥有m个子节点，其中m称为B树的阶数。

插入操作：

当要插入一个关键字时，从根节点开始，判断关键字应插入的位置。
如果节点已满（即已有m-1个关键字），则需要进行节点分裂操作。将中间位置
的关键字提升为父节点，并将节点分裂为两个节点，将剩余的关键字均匀分配到
这两个节点中。
如果要插入的节点还没有满，则直接将关键字插入到合适的位置。

删除操作：

当要删除一个关键字时，从根节点开始，找到包含该关键字的节点。
如果该节点是叶子节点，直接删除关键字。
如果该节点是内部节点，有几种情况需要处理：
如果该节点有足够多的关键字，则可以直接删除关键字。
如果该节点的关键字数量过少，需要考虑兄弟节点的关键字数量以及兄弟节点合
并的情况。

查询操作：

B树的查询操作与二叉查找树类似，从根节点开始，根据关键字的大小比较，向
左或向右子节点递归查询，直到找到匹配的关键字或遇到叶子节点。
B树适用于大规模数据存储和查询的场景，特别适用于外部存储设备上的数据存
储。其平衡性保证了较为均衡的查询性能，因为从根节点到叶子节点的路径长度
相等或差别不大。B树的阶数m可以根据具体应用和硬件限制来选择，较大的阶数
有助于减少磁盘访问的次数，提高效率。

强调

B树的变种B+树在B树的基础上做了一些优化，将所有的数据都存储在叶子节点
中，使得范围查询和顺序访问更加高效。因此，B+树在现代数据库系统和文件
系统中更为常见和广泛应用。、

代码实现

import java.util.ArrayList;
import java.util.List;

class BTreeNode {
    int degree; // B树的阶数
    List<Integer> keys; // 节点中存储的关键字
    List<BTreeNode> children; // 节点的子节点
    boolean isLeaf; // 是否是叶子节点

    public BTreeNode(int degree, boolean isLeaf) {
        this.degree = degree;
        this.isLeaf = isLeaf;
        keys = new ArrayList<>();
        children = new ArrayList<>();
    }
}

class BTree {
    BTreeNode root; // B树的根节点
    int degree; // B树的阶数

    public BTree(int degree) {
        this.degree = degree;
        root = new BTreeNode(degree, true);
    }

    // 插入关键字
    public void insert(int key) {
        if (root.keys.size() == (2 * degree - 1)) {
            BTreeNode newRoot = new BTreeNode(degree, false);
            newRoot.children.add(root);
            splitChild(newRoot, 0, root);
            root = newRoot;
        }
        insertNonFull(root, key);
    }

    // 在非满节点插入关键字
    private void insertNonFull(BTreeNode node, int key) {
        int index = node.keys.size() - 1;
        if (node.isLeaf) {
            while (index >= 0 && key < node.keys.get(index)) {
                index--;
            }
            node.keys.add(index + 1, key);
        } else {
            while (index >= 0 && key < node.keys.get(index)) {
                index--;
            }
            index++;
            if (node.children.get(index).keys.size() == (2 * degree - 1)) {
                splitChild(node, index, node.children.get(index));
                if (key > node.keys.get(index)) {
                    index++;
                }
            }
            insertNonFull(node.children.get(index), key);
        }
    }

    // 分裂子节点
    private void splitChild(BTreeNode parent, int index, BTreeNode node) {
        BTreeNode newNode = new BTreeNode(degree, node.isLeaf);
        parent.keys.add(index, node.keys.get(degree - 1));
        parent.children.add(index + 1, newNode);
        for (int i = 0; i < degree - 1; i++) {
            newNode.keys.add(node.keys.get(i + degree));
            if (!node.isLeaf) {
                newNode.children.add(node.children.get(i + degree));
            }
        }
        if (!node.isLeaf) {
            newNode.children.add(node.children.get(2 * degree - 1));
        }
        for (int i = degree - 1; i >= 0; i--) {
            node.keys.remove(i + degree - 1);
            if (!node.isLeaf) {
                node.children.remove(i + degree);
            }
        }
    }

    // 搜索关键字
    public boolean search(int key) {
        return search(root, key);
    }

    private boolean search(BTreeNode node, int key) {
        int index = 0;
        while (index < node.keys.size() && key > node.keys.get(index)) {
            index++;
        }
        if (index < node.keys.size() && key == node.keys.get(index)) {
            return true;
        } else if (node.isLeaf) {
            return false;
        } else {
            return search(node.children.get(index), key);
        }
    }
}

Trie树（字典树或前缀树）

Trie树，也被称为字典树或前缀树，是一种用于高效存储和搜索字符串的树型数
据结构。Trie树的主要特点是通过字符串的前缀来进行搜索和匹配。

结构特点：

Trie树由根节点和一系列子节点组成。
根节点不包含任何关键字，每个子节点都表示一个字符，并按字符的顺序连接形
成路径。
从根节点到每个叶子节点的路径都对应一个字符串。
每个节点可以存储额外的信息，如词频或附加数据等。

插入操作：

当要插入一个字符串时，从根节点开始，逐个字符按顺序插入。
如果某个字符对应的子节点不存在，则创建一个新的子节点。
插入字符串的最后一个字符后，将当前节点标记为一个单词的结束。

搜索操作：

当要搜索一个字符串时，从根节点开始，逐个字符按顺序匹配。
如果某个字符对应的子节点存在，则继续匹配下一个字符。
如果匹配遇到缺失的字符或到达某个节点后没有子节点，则表示字符串不在Trie
树中。
如果匹配成功并且在Trie树中找到最后一个字符，则表示字符串存在于Trie树中。

删除操作：

当要删除一个字符串时，从根节点开始，逐个字符按顺序遍历。
如果遍历过程中发现某个字符对应的子节点不存在，则表示字符串不存在于Trie
树中。
如果遍历成功，并到达字符串的最后一个字符，将当前节点的结束标记取消。
如果遍历成功，但还存在其他相关字符串（例如，删除"abc"但还有"abcd"），
可以保留当前节点以表示其他相关字符串。

优点：

搜索的时间复杂度与字符串长度无关，仅与Trie树的高度相关，通常比哈希表更
高效。
可以高效地搜索具有相同前缀的字符串集合。
对于字符串的前缀匹配和自动补全，Trie树可以提供高效的结果。

缺点:

空间消耗较大，尤其在处理大量长字符串时。为了缓解这个问题，可以使用压缩
的Trie树，如压缩前缀树（Patricia树）或Trie树的变种来减少存储空间。

代码实现

class TrieNode {
    private TrieNode[] children;
    private boolean isEndOfWord;

    public TrieNode() {
        children = new TrieNode[26]; // 26个英文字母
        isEndOfWord = false;
    }

    public TrieNode getChild(char ch) {
        return children[ch - 'a'];
    }

    public void setChild(char ch, TrieNode node) {
        children[ch - 'a'] = node;
    }

    public boolean isEndOfWord() {
        return isEndOfWord;
    }

    public void setEndOfWord(boolean isEndOfWord) {
        this.isEndOfWord = isEndOfWord;
    }
}

class Trie {
    private TrieNode root;

    public Trie() {
        root = new TrieNode();
    }

    public void insert(String word) {
        TrieNode node = root;
        for (char ch : word.toCharArray()) {
            if (node.getChild(ch) == null) {
                node.setChild(ch, new TrieNode());
            }
            node = node.getChild(ch);
        }
        node.setEndOfWord(true);
    }

    public boolean search(String word) {
        TrieNode node = findNode(word);
        return node != null && node.isEndOfWord();
    }

    public boolean startsWith(String prefix) {
        TrieNode node = findNode(prefix);
        return node != null;
    }

    private TrieNode findNode(String str) {
        TrieNode node = root;
        for (char ch : str.toCharArray()) {
            node = node.getChild(ch);
            if (node == null) {
                return null;
            }
        }
        return node;
    }
}

使用示例

public class Main {
    public static void main(String[] args) {
        Trie trie = new Trie();
        trie.insert("apple");
        trie.insert("banana");
        trie.insert("grape");
        
        System.out.println(trie.search("apple")); // 输出: true
        System.out.println(trie.search("orange")); // 输出: false
        
        System.out.println(trie.startsWith("app")); // 输出: true
        System.out.println(trie.startsWith("ban")); // 输出: true
        System.out.println(trie.startsWith("grap")); // 输出: true
    }
}