Introduction

In data structures, a Dictionary is an important abstract data type used to store data in the form of key-value pairs. Instead of accessing data using a numeric index like an array, a dictionary allows us to access data using a meaningful key.

A dictionary is also known by different names in different programming languages. In some languages it is called a Map, in some it is called a HashMap, and in some it is called an Associative Array. Although the names may be different, the core concept remains the same: store a value and retrieve it using a unique key.

Real-Life Example of Dictionary

If we want Amit's phone number, we do not need to check every number one by one. We simply search using the key "Amit" and get the value 9123456780.

Definition of Dictionary

Each key in a dictionary must be unique. A single key points to one specific value. However, different keys may have the same value depending on the situation.

Example

{
    "student_id": 101,
    "name": "Rumman Ansari",
    "course": "Data Structures",
    "city": "Kolkata"
}

In the above example, student_id, name, course, and city are keys. Their corresponding data such as 101, Rumman Ansari, Data Structures, and Kolkata are values.

Prerequisites to Understand Dictionary

Before learning Dictionary in data structure, students should have a basic understanding of the following topics:

Why Do We Need Dictionary?

Suppose we have a list of students and their marks. If we store the data in an array, we may need to search through the entire array to find the marks of a particular student. This can be slow when the data size is large.

A dictionary solves this problem by allowing direct access using a key. If the student's name or roll number is used as the key, the marks can be found quickly.

Structure of Dictionary

A dictionary is made up of multiple entries. Each entry contains two parts:

Characteristics of Dictionary

Basic Operations on Dictionary

A dictionary supports several important operations. These operations make dictionary useful in many practical programming problems.

Dictionary Operations Summary

Dictionary Example Using JavaScript

In JavaScript, a dictionary-like structure can be created using an object or the Map data structure. The following example shows basic dictionary operations using a JavaScript object.

// Creating a dictionary using JavaScript object
let student = {
    rollNo: 101,
    name: "Rumman Ansari",
    course: "Data Structures"
};

// Access value using key
console.log(student.name);

// Insert new key-value pair
student.city = "Kolkata";

// Update existing value
student.course = "DSA";

// Delete key-value pair
delete student.rollNo;

// Display final dictionary
console.log(student);

Output

Rumman Ansari

{
    name: "Rumman Ansari",
    course: "DSA",
    city: "Kolkata"
}

Dictionary Example Using Java HashMap

In Java, dictionary functionality is commonly implemented using HashMap. HashMap stores data in key-value pairs and provides fast access using keys.

import java.util.HashMap;

public class DictionaryExample {
    public static void main(String[] args) {

        HashMap<Integer, String> students = new HashMap<>();

        // Insert key-value pairs
        students.put(101, "Rumman");
        students.put(102, "Amit");
        students.put(103, "Priya");

        // Search value using key
        System.out.println(students.get(101));

        // Update value
        students.put(102, "Amit Kumar");

        // Delete value
        students.remove(103);

        // Display dictionary
        System.out.println(students);
    }
}

Output

Rumman
{101=Rumman, 102=Amit Kumar}

Internal Working of Dictionary

Most dictionaries are internally implemented using a concept called Hashing. Hashing helps convert a key into an index where the value can be stored or found quickly.

A hash function takes a key as input and converts it into a numeric index. This index helps the dictionary decide where to store the value in memory.

Simple Hash Function Example

Suppose we have a key 101 and table size 10. A simple hash function can be:

Now calculate:

So, the value related to key 101 may be stored at index 1. This makes searching faster because the dictionary can directly calculate the location.

What is Collision in Dictionary?

A collision occurs when two different keys generate the same index using the hash function. Since both keys want to store values at the same location, the dictionary must handle this situation carefully.

Example of Collision

Suppose the table size is 10:

Both keys 101 and 111 generate index 1. This is called a collision.

Collision Handling Techniques

Time Complexity of Dictionary

Time complexity tells us how much time an operation takes as the size of data increases. Dictionary operations are usually very fast because of hashing.

Space Complexity of Dictionary

Space complexity of a dictionary is generally O(n), where n is the number of key-value pairs. This is because memory is required to store every key and its associated value.

Sometimes dictionaries may require extra memory to maintain internal hash tables, empty slots, or linked structures for collision handling.

Dictionary vs Array

Arrays and dictionaries are both used to store data, but they are used in different situations. Arrays are index-based, while dictionaries are key-based.

Types of Dictionary

Based on internal implementation and ordering behavior, dictionaries can be classified into different types.

Dictionary Implementation Methods

Advantages of Dictionary

Disadvantages of Dictionary

Applications of Dictionary

Dictionaries are widely used in programming because many real-world problems involve finding data using a unique identifier.

Practical Example: Counting Word Frequency

One common use of dictionary is to count how many times each word appears in a sentence. In this case, the word becomes the key and its frequency becomes the value.

let sentence = "data structure data dictionary structure data";
let words = sentence.split(" ");

let frequency = {};

for (let word of words) {
    if (frequency[word]) {
        frequency[word] = frequency[word] + 1;
    } else {
        frequency[word] = 1;
    }
}

console.log(frequency);

Output

{
    data: 3,
    structure: 2,
    dictionary: 1
}

This example shows how dictionary can be used for frequency counting. This technique is very useful in text processing, search engines, data analysis, and natural language processing.

When Should We Use Dictionary?

Common Mistakes Students Make

Interview Questions on Dictionary

Quick Revision

Conclusion

A Dictionary is one of the most useful and powerful data structures in computer science. It allows data to be stored in a meaningful way using key-value pairs. Instead of remembering numeric positions, programmers can use meaningful keys to access values quickly.

Dictionaries are commonly used in applications where fast lookup, insertion, deletion, and update operations are required. They are used in databases, caches, phone books, student management systems, compilers, APIs, search engines, and many other real-world systems.