// C++ implementation of Hashtable   // using doubly linked list   #include          using     namespace     std  ;   const     int     tablesize     =     25  ;   // declaration of node   struct     hash_node     {      int     val       key  ;      hash_node  *     next  ;      hash_node  *     prev  ;   };   // hashmap's declaration   class     HashMap     {   public  :      hash_node     **  hashtable       **  top  ;      // constructor      HashMap  ()      {      // create a empty hashtable      hashtable     =     new     hash_node  *  [  tablesize  ];      top     =     new     hash_node  *  [  tablesize  ];      for     (  int     i     =     0  ;     i      <     tablesize  ;     i  ++  )     {      hashtable  [  i  ]     =     NULL  ;      top  [  i  ]     =     NULL  ;      }      }      // destructor      ~  HashMap  ()      {      delete  []     hashtable  ;      }      // hash function definition      int     HashFunc  (  int     key  )      {      return     key     %     tablesize  ;      }      // searching method      void     find  (  int     key  )      {      // Applying hashFunc to find      // index for given key      int     hash_val     =     HashFunc  (  key  );      bool     flag     =     false  ;      hash_node  *     entry     =     hashtable  [  hash_val  ];      // if hashtable at that index has some      // values stored      if     (  entry     !=     NULL  )     {      while     (  entry     !=     NULL  )     {      if     (  entry  ->  key     ==     key  )     {      flag     =     true  ;      }      if     (  flag  )     {      cout      < <     'Element found at key '       < <     key      < <     ': '  ;      cout      < <     entry  ->  val      < <     endl  ;      }      entry     =     entry  ->  next  ;      }      }      if     (  !  flag  )      cout      < <     'No Element found at key '       < <     key      < <     endl  ;      }      // removing an element      void     remove  (  int     key  )      {      // Applying hashFunc to find      // index for given key      int     hash_val     =     HashFunc  (  key  );      hash_node  *     entry     =     hashtable  [  hash_val  ];      if     (  entry  ->  key     !=     key     ||     entry     ==     NULL  )     {      cout      < <     'Couldn't find any element at this key '       < <     key      < <     endl  ;      return  ;      }      // if some values are present at that key &      // traversing the list and removing all values      while     (  entry     !=     NULL  )     {      if     (  entry  ->  next     ==     NULL  )     {      if     (  entry  ->  prev     ==     NULL  )     {      hashtable  [  hash_val  ]     =     NULL  ;      top  [  hash_val  ]     =     NULL  ;      delete     entry  ;      break  ;      }      else     {      top  [  hash_val  ]     =     entry  ->  prev  ;      top  [  hash_val  ]  ->  next     =     NULL  ;      delete     entry  ;      entry     =     top  [  hash_val  ];      }      }      entry     =     entry  ->  next  ;      }      cout      < <     'Element was successfully removed at the key '       < <     key      < <     endl  ;      }      // inserting method      void     add  (  int     key       int     value  )      {      // Applying hashFunc to find      // index for given key      int     hash_val     =     HashFunc  (  key  );      hash_node  *     entry     =     hashtable  [  hash_val  ];      // if key has no value stored      if     (  entry     ==     NULL  )     {      // creating new node      entry     =     new     hash_node  ;      entry  ->  val     =     value  ;      entry  ->  key     =     key  ;      entry  ->  next     =     NULL  ;      entry  ->  prev     =     NULL  ;      hashtable  [  hash_val  ]     =     entry  ;      top  [  hash_val  ]     =     entry  ;      }      // if some values are present      else     {      // traversing till the end of      // the list      while     (  entry     !=     NULL  )      entry     =     entry  ->  next  ;      // creating the new node      entry     =     new     hash_node  ;      entry  ->  val     =     value  ;      entry  ->  key     =     key  ;      entry  ->  next     =     NULL  ;      entry  ->  prev     =     top  [  hash_val  ];      top  [  hash_val  ]  ->  next     =     entry  ;      top  [  hash_val  ]     =     entry  ;      }      cout      < <     'Value '      < <     value      < <     ' was successfully'      ' added at key '      < <     key      < <     endl  ;      }   };   // Driver Code   int     main  ()   {      HashMap     hash  ;      hash  .  add  (  4       5  );      hash  .  find  (  4  );      hash  .  remove  (  4  );      return     0  ;   }   

   // Java implementation of Hashtable   // using doubly linked list   class   GFG     {      static     final     int     tablesize     =     25  ;      // declaration of node      static     class   hash_node     {      int     val       key  ;      hash_node     next  ;      hash_node     prev  ;      }      // hashmap's declaration      static     class   HashMap     {      hash_node     hashtable  []       top  []  ;      // constructor      HashMap  ()      {      // create a empty hashtable      hashtable     =     new     hash_node  [  tablesize  ]  ;      top     =     new     hash_node  [  tablesize  ]  ;      for     (  int     i     =     0  ;     i      <     tablesize  ;     i  ++  )     {      hashtable  [  i  ]     =     null  ;      top  [  i  ]     =     null  ;      }      }      // hash function definition      int     HashFunc  (  int     key  )     {     return     key     %     tablesize  ;     }      // searching method      void     find  (  int     key  )      {      // Applying hashFunc to find      // index for given key      int     hash_val     =     HashFunc  (  key  );      boolean     flag     =     false  ;      hash_node     entry     =     hashtable  [  hash_val  ]  ;      // if hashtable at that index has some      // values stored      if     (  entry     !=     null  )     {      while     (  entry     !=     null  )     {      if     (  entry  .  key     ==     key  )     {      flag     =     true  ;      }      if     (  flag  )     {      System  .  out  .  println  (      'Element found at key '     +     key      +     ': '     +     entry  .  val  );      }      entry     =     entry  .  next  ;      }      }      if     (  !  flag  )      System  .  out  .  println  (      'No Element found at key '     +     key  );      }      // removing an element      void     remove  (  int     key  )      {      // Applying hashFunc to find      // index for given key      int     hash_val     =     HashFunc  (  key  );      hash_node     entry     =     hashtable  [  hash_val  ]  ;      if     (  entry  .  key     !=     key     ||     entry     ==     null  )     {      System  .  out  .  println  (      'Couldn't find any element at this key '      +     key  );      return  ;      }      // if some values are present at that key &      // traversing the list and removing all values      while     (  entry     !=     null  )     {      if     (  entry  .  next     ==     null  )     {      if     (  entry  .  prev     ==     null  )     {      hashtable  [  hash_val  ]     =     null  ;      top  [  hash_val  ]     =     null  ;      break  ;      }      else     {      top  [  hash_val  ]     =     entry  .  prev  ;      top  [  hash_val  ]  .  next     =     null  ;      entry     =     top  [  hash_val  ]  ;      }      }      entry     =     entry  .  next  ;      }      System  .  out  .  println  (      'Element was successfully removed at the key '      +     key  );      }      // inserting method      void     add  (  int     key       int     value  )      {      // Applying hashFunc to find      // index for given key      int     hash_val     =     HashFunc  (  key  );      hash_node     entry     =     hashtable  [  hash_val  ]  ;      // if key has no value stored      if     (  entry     ==     null  )     {      // creating new node      entry     =     new     hash_node  ();      entry  .  val     =     value  ;      entry  .  key     =     key  ;      entry  .  next     =     null  ;      entry  .  prev     =     null  ;      hashtable  [  hash_val  ]     =     entry  ;      top  [  hash_val  ]     =     entry  ;      }      // if some values are present      else     {      // traversing till the end of      // the list      while     (  entry     !=     null  )      entry     =     entry  .  next  ;      // creating the new node      entry     =     new     hash_node  ();      entry  .  val     =     value  ;      entry  .  key     =     key  ;      entry  .  next     =     null  ;      entry  .  prev     =     top  [  hash_val  ]  ;      top  [  hash_val  ]  .  next     =     entry  ;      top  [  hash_val  ]     =     entry  ;      }      System  .  out  .  println  (      'Value '     +     value      +     ' was successfully added at key '     +     key  );      }      }      // Driver Code      public     static     void     main  (  String  []     args  )      {      HashMap     hash     =     new     HashMap  ();      hash  .  add  (  4       5  );      hash  .  find  (  4  );      hash  .  remove  (  4  );      }   }   // This code is contributed by Lovely Jain   

   # Python implementation of Hashtable   # using doubly linked list   # declaration of node   class   hash_node  :   def   __init__  (  self     val     key  ):   self  .  val   =   val   self  .  key   =   key   self  .  next   =   None   self  .  prev   =   None   # hashmap's declaration   class   HashMap  :   def   __init__  (  self  ):   # create an empty hashtable   self  .  tablesize   =   25   self  .  hashtable   =   [  None  ]   *   self  .  tablesize   self  .  top   =   [  None  ]   *   self  .  tablesize   # hash function definition   def   HashFunc  (  self     key  ):   return   key   %   self  .  tablesize   # searching method   def   find  (  self     key  ):   # Applying hashFunc to find   # index for given key   hash_val   =   self  .  HashFunc  (  key  )   flag   =   False   entry   =   self  .  hashtable  [  hash_val  ]   # if hashtable at that index has some   # values stored   if   entry   is   not   None  :   while   entry   is   not   None  :   if   entry  .  key   ==   key  :   flag   =   True   if   flag  :   print  (  'Element found at key'     key     ':'     entry  .  val  )   entry   =   entry  .  next   if   not   flag  :   print  (  'No Element found at key'     key  )   # removing an element   def   remove  (  self     key  ):   # Applying hashFunc to find   # index for given key   hash_val   =   self  .  HashFunc  (  key  )   entry   =   self  .  hashtable  [  hash_val  ]   if   entry   is   None   or   entry  .  key   !=   key  :   print  (  'Couldn't find any element at this key'     key  )   return   # if some values are present at that key &   # traversing the list and removing all values   while   entry   is   not   None  :   if   entry  .  next   is   None  :   if   entry  .  prev   is   None  :   self  .  hashtable  [  hash_val  ]   =   None   self  .  top  [  hash_val  ]   =   None   del   entry   break   else  :   self  .  top  [  hash_val  ]   =   entry  .  prev   self  .  top  [  hash_val  ]  .  next   =   None   del   entry   entry   =   self  .  top  [  hash_val  ]   entry   =   entry  .  next   print  (  'Element was successfully removed at the key'     key  )   # inserting method   def   add  (  self     key     value  ):   # Applying hashFunc to find   # index for given key   hash_val   =   self  .  HashFunc  (  key  )   entry   =   self  .  hashtable  [  hash_val  ]   # if key has no value stored   if   entry   is   None  :   # creating new node   entry   =   hash_node  (  value     key  )   self  .  hashtable  [  hash_val  ]   =   entry   self  .  top  [  hash_val  ]   =   entry   # if some values are present   else  :   # traversing till the end of   # the list   while   entry  .  next   is   not   None  :   entry   =   entry  .  next   # creating the new node   new_entry   =   hash_node  (  value     key  )   new_entry  .  prev   =   entry   entry  .  next   =   new_entry   self  .  top  [  hash_val  ]   =   new_entry   print  (  'Value'     value     'was successfully added at key'     key  )   # Driver Code   if   __name__   ==   '__main__'  :   hash_map   =   HashMap  ()   hash_map  .  add  (  4     5  )   hash_map  .  find  (  4  )   hash_map  .  remove  (  4  )   

   // Java implementation of Hashtable using doubly linked list   class     GFG     {      static     final     int     tablesize     =     25  ;      // declaration of node      static     class     hash_node     {      int     val       key  ;      hash_node     next  ;      hash_node     prev  ;      }      // hashmap's declaration      static     class     HashMap     {      hash_node     hashtable  []     top  [];      // constructor      HashMap  (){      // create a empty hashtable      hashtable     =     new     hash_node  [  tablesize  ];      top     =     new     hash_node  [  tablesize  ];      for     (  int     i     =     0  ;     i      <     tablesize  ;     i  ++  )     {      hashtable  [  i  ]     =     null  ;      top  [  i  ]     =     null  ;      }      }      // hash function definition      int     HashFunc  (  int     key  )     {     return     key     %     tablesize  ;     }      // searching method      void     find  (  int     key  )      {      // Applying hashFunc to find index for given key      int     hash_val     =     HashFunc  (  key  );     boolean     flag     =     false  ;      hash_node     entry     =     hashtable  [  hash_val  ];      // if hashtable at that index has some values stored      if     (  entry     !=     null  )     {      while     (  entry     !=     null  )     {      if     (  entry  .  key     ==     key  )     flag     =     true  ;      if     (  flag  )     {      System  .  out  .  println  (  'Element found at key '     +     key  +     ': '     +     entry  .  val  );      }      entry     =     entry  .  next  ;      }      }      if     (  !  flag  )      System  .  out  .  println  (  'No Element found at key '     +     key  );      }      // removing an element      void     remove  (  int     key  )      {      // Applying hashFunc to find index for given key      int     hash_val     =     HashFunc  (  key  );      hash_node     entry     =     hashtable  [  hash_val  ];      if     (  entry  .  key     !=     key     ||     entry     ==     null  )     {      System  .  out  .  println  (  'Couldn't find any element at this key '  +     key  );      return  ;      }      // if some values are present at that key & traversing the list and removing all values      while     (  entry     !=     null  )     {      if     (  entry  .  next     ==     null  )     {      if     (  entry  .  prev     ==     null  )     {      hashtable  [  hash_val  ]     =     null  ;      top  [  hash_val  ]     =     null  ;      break  ;      }      else     {      top  [  hash_val  ]     =     entry  .  prev  ;      top  [  hash_val  ].  next     =     null  ;      entry     =     top  [  hash_val  ];      }      }      entry     =     entry  .  next  ;      }      System  .  out  .  println  (      'Element was successfully removed at the key '      +     key  );      }      // inserting method      void     add  (  int     key       int     value  )      {      // Applying hashFunc to find index for given key      int     hash_val     =     HashFunc  (  key  );      hash_node     entry     =     hashtable  [  hash_val  ];      // if key has no value stored      if     (  entry     ==     null  )     {      // creating new node      entry     =     new     hash_node  ();      entry  .  val     =     value  ;      entry  .  key     =     key  ;      entry  .  next     =     null  ;      entry  .  prev     =     null  ;      hashtable  [  hash_val  ]     =     entry  ;      top  [  hash_val  ]     =     entry  ;      }      // if some values are present      else     {      // traversing till the end of      // the list      while     (  entry     !=     null  )      entry     =     entry  .  next  ;      // creating the new node      entry     =     new     hash_node  ();      entry  .  val     =     value  ;      entry  .  key     =     key  ;      entry  .  next     =     null  ;      entry  .  prev     =     top  [  hash_val  ];      top  [  hash_val  ].  next     =     entry  ;      top  [  hash_val  ]     =     entry  ;      }      System  .  out  .  println  (      'Value '     +     value      +     ' was successfully added at key '     +     key  );      }      }      // Driver Code      public     static     void     main  (  String  []     args  )      {      HashMap     hash     =     new     HashMap  ();      hash  .  add  (  4       5  );      hash  .  find  (  4  );      hash  .  remove  (  4  );      }   }   // This code is contributed by Lovely Jain   

   // JavaScript implementation of Hashtable using doubly linked list   const     tablesize     =     25  ;   // declaration of node   class     hash_node     {   constructor  (  key       val  )     {   this  .  key     =     key  ;   this  .  val     =     val  ;   this  .  next     =     null  ;   this  .  prev     =     null  ;   }   }   // hashmap's declaration   class     HashMap     {   constructor  ()     {   // create a empty hashtable   this  .  hashtable     =     new     Array  (  tablesize  ).  fill  (  null  );   this  .  top     =     new     Array  (  tablesize  ).  fill  (  null  );   }   // hash function definition   HashFunc  (  key  )     {   return     key     %     tablesize  ;   }   // searching method   find  (  key  )     {   // Applying hashFunc to find index for given key   const     hash_val     =     this  .  HashFunc  (  key  );   let     flag     =     false  ;   let     entry     =     this  .  hashtable  [  hash_val  ];   // if hashtable at that index has some values stored   if     (  entry     !==     null  )     {      while     (  entry     !==     null  )     {      if     (  entry  .  key     ===     key  )     flag     =     true  ;      if     (  flag  )     {      console  .  log  (  `Element found at key   ${  key  }  :   ${  entry  .  val  }  `  );      }      entry     =     entry  .  next  ;      }   }   if     (  !  flag  )     console  .  log  (  `No Element found at key   ${  key  }  `  );   }   // removing an element   remove  (  key  )     {   // Applying hashFunc to find index for given key   const     hash_val     =     this  .  HashFunc  (  key  );   let     entry     =     this  .  hashtable  [  hash_val  ];   if     (  entry  .  key     !==     key     ||     entry     ===     null  )     {      console  .  log  (  `Couldn't find any element at this key   ${  key  }  `  );      return  ;   }   // if some values are present at that key & traversing the list and removing all values   while     (  entry     !==     null  )     {      if     (  entry  .  next     ===     null  )     {      if     (  entry  .  prev     ===     null  )     {      this  .  hashtable  [  hash_val  ]     =     null  ;      this  .  top  [  hash_val  ]     =     null  ;      break  ;      }     else     {      this  .  top  [  hash_val  ]     =     entry  .  prev  ;      this  .  top  [  hash_val  ].  next     =     null  ;      entry     =     this  .  top  [  hash_val  ];      }      }      entry     =     entry  .  next  ;   }   console  .  log  (  `Element was successfully removed at the key   ${  key  }  `  );   }   // inserting method   add  (  key       value  )     {   // Applying hashFunc to find index for given key   const     hash_val     =     this  .  HashFunc  (  key  );   let     entry     =     this  .  hashtable  [  hash_val  ];   // if key has no value stored   if     (  entry     ===     null  )     {      // creating new node      entry     =     new     hash_node  (  key       value  );      this  .  hashtable  [  hash_val  ]     =     entry  ;      this  .  top  [  hash_val  ]     =     entry  ;   }   // if some values are present   else     {      // traversing till the end of the list      while     (  entry     !==     null  )     entry     =     entry  .  next  ;      // creating the new node      entry     =     new     hash_node  (  key       value  );      entry  .  prev     =     this  .  top  [  hash_val  ];      this  .  top  [  hash_val  ].  next     =     entry  ;      this  .  top  [  hash_val  ]     =     entry  ;   }   console  .  log  (  `Value   ${  value  }   was successfully added at key   ${  key  }  `  );   }   }   // Driver Code   const     hash     =     new     HashMap  ();   hash  .  add  (  4       5  );   hash  .  find  (  4  );   hash  .  remove  (  4  );