Algorithm Insert
  Input: Node N of M-Tree MT, Entry ${\displaystyle O_{n}}$
  Output: A new instance of MT containing all entries in original MT plus ${\displaystyle O_{n}}$

  ${\displaystyle N_{e}\gets N}$'s routing objects or objects
  if N is not a leaf then
  {
       /* Look for entries that the new object fits into */
       let ${\displaystyle N_{in}}$ be routing objects from ${\displaystyle N_{e}}$'s set of routing objects ${\displaystyle N_{RO}}$ such that ${\displaystyle d(O_{r},O_{n})\leq r(O_{r})}$
       if ${\displaystyle N_{in}}$ is not empty then
       {
          /* If there are one or more entry, then look for an entry such that is closer to the new object */
          ${\displaystyle O_{r}^{*}\gets \min _{O_{r}\in N_{in}}d(O_{r},O_{n})}$
       }
       else
       {
          /* If there are no such entry, then look for an object with minimal distance from */ 
          /* its covering radius's edge to the new object */
          ${\displaystyle O_{r}^{*}\gets \min _{O_{r}\in N_{in}}d(O_{r},O_{n})-r(O_{r})}$
          /* Upgrade the new radii of the entry */
          ${\displaystyle r(O_{r}^{*})\gets d(O_{r}^{*},O_{n})}$
       }
       /* Continue inserting in the next level */
       return insert(${\displaystyle T(O_{r}^{*}),O_{n}}$);
  else
  {
       /* If the node has capacity then just insert the new object */
       if N is not full then
       { store(${\displaystyle N,O_{n}}$) }
       /* The node is at full capacity, then it is needed to do a new split in this level */
       else
       { split(${\displaystyle N,O_{n}}$) }
  }

• "←" denotes assignment. For instance, "largest ← item" means that the value of largest changes to the value of item.
• "return" terminates the algorithm and outputs the following value.

Algorithm Split
  Input: Node N of M-Tree MT, Entry ${\displaystyle O_{n}}$
  Output: A new instance of MT containing a new partition.

  /* The new routing objects are now all those in the node plus the new routing object */
  let be NN entries of ${\displaystyle N\cup O}$
  if N is not the root then
  {
     /*Get the parent node and the parent routing object*/
     let ${\displaystyle O_{p}}$ be the parent routing object of N
     let ${\displaystyle N_{p}}$ be the parent node of N
  }
  /* This node will contain part of the objects of the node to be split */
  Create a new node N'
  /* Promote two routing objects from the node to be split, to be new routing objects */
  Create new objects ${\displaystyle O_{p1}}$ and ${\displaystyle O_{p2}}$.
  Promote(${\displaystyle N,O_{p1},O_{p2}}$)
  /* Choose which objects from the node being split will act as new routing objects */
  Partition(${\displaystyle N,O_{p1},O_{p2},N_{1},N_{2}}$)
  /* Store entries in each new routing object */
  Store ${\displaystyle N_{1}}$'s entries in N and ${\displaystyle N_{2}}$'s entries in N'
  if N is the current root then
  {
      /* Create a new node and set it as new root and store the new routing objects */
      Create a new root node ${\displaystyle N_{p}}$
      Store ${\displaystyle O_{p1}}$ and ${\displaystyle O_{p2}}$ in ${\displaystyle N_{p}}$
  }
  else
  {
      /* Now use the parent routing object to store one of the new objects */
      Replace entry ${\displaystyle O_{p}}$ with entry ${\displaystyle O_{p1}}$ in ${\displaystyle N_{p}}$
      if ${\displaystyle N_{p}}$ is no full then
      {
          /* The second routing object is stored in the parent only if it has free capacity */
          Store ${\displaystyle O_{p2}}$ in ${\displaystyle N_{p}}$
      }
      else
      {
           /*If there is no free capacity then split the level up*/
           split(${\displaystyle N_{p},O_{p2}}$)
      }
  }

• "←" denotes assignment. For instance, "largest ← item" means that the value of largest changes to the value of item.
• "return" terminates the algorithm and outputs the following value.

Algorithm RangeSearch
Input: Node N of M-Tree MT,  Q: query object, ${\displaystyle r(Q)}$: search radius

Output: all the DB objects such that ${\displaystyle d(Oj,Q)\leq r(Q)}$

{ 
  let ${\displaystyle O_{p}}$ be the parent object of node N;

  if N is not a leaf then { 
    for each entry(${\displaystyle O_{r}}$) in N do {
          if ${\displaystyle |d(O_{p},Q)-d(O_{r},O_{p})|\leq r(Q)+r(O_{r})}$ then { 
            Compute ${\displaystyle d(O_{r},Q)}$;
            if ${\displaystyle d(O_{r},Q)\leq r(Q)+r(O_{r})}$ then
              RangeSearch(*ptr(${\displaystyle T(O_{r}}$)),Q,${\displaystyle r(Q)}$); 
          }
    }
  }
  else { 
    for each entry(${\displaystyle O_{j}}$) in N do {
          if ${\displaystyle |d(O_{p},Q)-d(O_{j},O_{p})|\leq r(Q)}$ then { 
            Compute ${\displaystyle d(O_{j},Q)}$;
            if ${\displaystyle d(O_{j},Q)}$ ≤ ${\displaystyle r(Q)}$ then
              add ${\displaystyle oid(O_{j})}$ to the result;
          }
    }
  }
}

• "←" denotes assignment. For instance, "largest ← item" means that the value of largest changes to the value of item.
• "return" terminates the algorithm and outputs the following value.