Phone Book (HashMap) - Problem

Implement a simple phone book using a hash map that supports four basic operations:

Add Contact: Add a name and phone number to the phone book
Search Contact: Find a phone number by name
Delete Contact: Remove a contact from the phone book
List All Contacts: Display all contacts in the phone book

Your implementation should handle multiple operations efficiently and return appropriate responses for each operation type.

The input will be a list of operations, where each operation is represented as [operation_type, name, phone_number] (phone_number is optional for some operations).

Operations:

["add", "John", "123-456-7890"] - Add John with phone 123-456-7890
["search", "John"] - Search for John's phone number
["delete", "John"] - Delete John from phone book
["list"] - List all contacts

Input & Output

Example 1 — Basic Operations

$ Input: operations = [["add", "John", "123-456-7890"], ["search", "John"], ["add", "Alice", "987-654-3210"], ["list"]]

› Output: ["Contact added", "123-456-7890", "Contact added", [["John", "123-456-7890"], ["Alice", "987-654-3210"]]]

💡 Note: Add John with phone 123-456-7890, search returns his number, add Alice, list shows both contacts

Example 2 — Delete Operation

$ Input: operations = [["add", "Bob", "555-1234"], ["delete", "Bob"], ["search", "Bob"]]

› Output: ["Contact added", "Contact deleted", "Contact not found"]

💡 Note: Add Bob, delete Bob successfully, searching for Bob returns not found

Example 3 — Empty Phone Book

$ Input: operations = [["search", "Nobody"], ["list"], ["delete", "Nobody"]]

› Output: ["Contact not found", [], "Contact not found"]

💡 Note: Search in empty phone book returns not found, list returns empty array, delete returns not found

Constraints

1 ≤ operations.length ≤ 1000
Each operation is valid format
Names contain only letters and spaces
Phone numbers contain digits and dashes

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 A Apple 18

The key insight is using a hash map for O(1) average-case lookups instead of O(n) linear search. Best approach is Hash Map with name as key and phone as value. Time: O(1) average per operation, Space: O(n) for storing contacts.

Common Approaches

✓ Hash Map Approach

⏱️ Time: O(1) Space: O(n)

Store contacts in a hash map with name as key and phone as value. This provides constant-time average case for add, search, and delete operations.

Linear Search Array

⏱️ Time: O(n) Space: O(n)

Use an array to store name-phone pairs. For each operation, scan through the entire array to find, add, or delete contacts. Simple but inefficient for large phone books.

Hash Map Approach — Algorithm Steps

Create hash map with name as key
For add: map[name] = phone
For search: return map[name]
For delete: remove map[name]
For list: iterate through map entries

Visualization

Tap to expand

Step-by-Step Walkthrough

Hash Function

Name converted to hash index

Direct Access

Jump directly to bucket

Result

Return phone number instantly

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_CONTACTS 1000
#define MAX_NAME_LEN 100
#define MAX_PHONE_LEN 20
#define HASH_SIZE 1009

struct Contact {
    char name[MAX_NAME_LEN];
    char phone[MAX_PHONE_LEN];
    struct Contact* next;
};

struct Contact* hashTable[HASH_SIZE];

unsigned int hash(char* str) {
    unsigned int hash = 5381;
    for (int i = 0; str[i]; i++) {
        hash = ((hash << 5) + hash) + str[i];
    }
    return hash % HASH_SIZE;
}

struct Contact* findContact(char* name) {
    unsigned int index = hash(name);
    struct Contact* current = hashTable[index];
    while (current != NULL) {
        if (strcmp(current->name, name) == 0) {
            return current;
        }
        current = current->next;
    }
    return NULL;
}

void addContact(char* name, char* phone) {
    struct Contact* existing = findContact(name);
    if (existing != NULL) {
        strcpy(existing->phone, phone);
        return;
    }
    
    struct Contact* newContact = malloc(sizeof(struct Contact));
    strcpy(newContact->name, name);
    strcpy(newContact->phone, phone);
    
    unsigned int index = hash(name);
    newContact->next = hashTable[index];
    hashTable[index] = newContact;
}

char* searchContact(char* name) {
    struct Contact* contact = findContact(name);
    if (contact != NULL) {
        return contact->phone;
    }
    return "Contact not found";
}

int deleteContact(char* name) {
    unsigned int index = hash(name);
    struct Contact* current = hashTable[index];
    struct Contact* prev = NULL;
    
    while (current != NULL) {
        if (strcmp(current->name, name) == 0) {
            if (prev == NULL) {
                hashTable[index] = current->next;
            } else {
                prev->next = current->next;
            }
            free(current);
            return 1;
        }
        prev = current;
        current = current->next;
    }
    return 0;
}

int main() {
    // Initialize hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        hashTable[i] = NULL;
    }
    
    // Simple demo
    addContact("John", "123-456-7890");
    printf("Contact added\n");
    
    char* result = searchContact("John");
    printf("%s\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Hash map provides constant-time average case for add, search, delete

✓ Linear Growth

Space Complexity

O(n)

Hash map stores n contacts

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Phone Book (HashMap) - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Hash Map Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler