Skip to content
Related Articles

Related Articles

m-WAY Search Trees | Set-1 ( Searching )
  • Difficulty Level : Hard
  • Last Updated : 20 Aug, 2019
GeeksforGeeks - Summer Carnival Banner

The m-way search trees are multi-way trees which are generalised versions of binary trees where each node contains multiple elements. In an m-Way tree of order m, each node contains a maximum of m – 1 elements and m children.

The goal of m-Way search tree of height h calls for O(h) no. of accesses for an insert/delete/retrieval operation. Hence, it ensures that the height h is close to log_m(n + 1).

The number of elements in an m-Way search tree of height h ranges from a minimum of h to a maximum of m^{h} -1.

An m-Way search tree of n elements ranges from a minimum height of log_m(n+1) to a maximum of n

An example of a 5-Way search tree is shown in the figure below. Observe how each node has at most 5 child nodes & therefore has at most 4 keys contained in it.

The structure of a node of an m-Way tree is given below:

struct node {
    int count;
    int value[MAX + 1];
    struct node* child[MAX + 1];
  • Here, count represents the number of children that a particular node has
  • The values of a node stored in the array value
  • The addresses of child nodes are stored in the child array
  • The MAX macro signifies the maximum number of values that a particular node can contain

Searching in an m-Way search tree:

  • Searching for a key in an m-Way search tree is similar to that of binary search tree
  • To search for 77 in the 5-Way search tree, shown in the figure, we begin at the root & as 77> 76> 44> 18, move to the fourth sub-tree
  • In the root node of the fourth sub-tree, 77< 80 & therefore we move to the first sub-tree of the node. Since 77 is available in the only node of this sub-tree, we claim 77 was successfully searched

// Searches value in the node
struct node* search(int val,
                    struct node* root,
                    int* pos)
    // if root is Null then return
    if (root == NULL)
        return NULL;
    else {
        // if node is found
        if (searchnode(val, root, pos))
            return root;
        // if not then search in child nodes
            return search(val,
// Searches the node
int searchnode(int val,
               struct node* n,
               int* pos)
    // if val is less than node->value[1]
    if (val < n->value[1]) {
        *pos = 0;
        return 0;
    // if the val is greater
    else {
        *pos = n->count;
        // check in the child array
        // for correct position
        while ((val < n->value[*pos])
               && *pos > 1)
        if (val == n->value[*pos])
            return 1;
            return 0;


  • The function search() receives three parameters
  • The first parameter is the value to be searched, second is the address of the node from where the search is to be performed and third is the address of a variable that is used to store the position of the value once found
  • Initially a condition is checked whether the address of the node being searched is NULL
  • If it is, then simply a NULL value is returned
  • Otherwise, a function searchnode() is called which actually searches the given value
  • If the search is successful the address of the node in which the value is found is returned
  • If the search is unsuccessful then a recursive call is made to the search() function for the child of the current node


  • The function searchnode() receives three parameters
  • The first parameter is the value that is to be searched
  • The second parameter is the address of the node in which the search is to be performed and third is a pointer pos that holds the address of a variable in which the position of the value that once found is stored
  • This function returns a value 0 if the search is unsuccessful and 1 if it is successful
  • In this function initially it is checked whether the value that is to be searched is less than the very first value of the node
  • If it is then it indicates that the value is not present in the current node. Hence, a value 0 is assigned in the variable that is pointed to by pos and 0 is returned, as the search is unsuccessful

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :