What You Can Learn in This Article

・The basic mechanisms and features of data structures

Introduction

There are various types of data structures, and each has its own advantages and disadvantages. Therefore, it is essential to choose the right data structure according to the program’s requirements. In this article, we aim to introduce the characteristics of various data structures, expanding the reader’s options and providing criteria for making informed choices.
Now, let’s get into the main topic. First, I’d like to explain what a data structure is.

What is a Data Structure?

A data structure refers to a formalized way of organizing and managing a collection of data in a specific format for a particular purpose. Data structures improve the performance of programs by enabling efficient searching, adding, deleting, and updating of data.
The choice of data structure has a significant impact on the performance of a program. By choosing the right data structure, you can improve execution speed and reduce memory usage. Moreover, the selection of a data structure also affects the maintainability of the program. A well-chosen data structure makes the code easier to understand and modify.
Now, let’s introduce specific data structures.

List

A list is a data structure used to store multiple elements in a specific order. Let’s explain it in detail with an example of a list consisting of three elements.

In a list, each node typically contains data and a pointer to the next node. In this example, the first two nodes contain Apple and a pointer, and Peach and a pointer, respectively. Note that the node containing Lemon does not have a pointer, as it is the last node, and there is no node after it.
Each node can only be accessed by following the pointers from the head. In this case, to access Lemon, you must first access Apple and then follow the pointer to Peach.
Adding data is easy since it only requires changing the pointers of the surrounding nodes. For example, to insert Mango between Peach and Lemon, you simply change Peach’s pointer to point to Mango and Mango’s pointer to Lemon.

Data deletion is also easy, similar to adding data, by changing the pointers. For example, to delete Mango, you simply change Peach’s pointer to point to Lemon.
In summary, lists are easy to add or delete data, but accessing data takes time. Here, we explained the basic mechanism of a singly linked list, but there are also other types, such as circular lists where the last node points to the first node, and doubly linked lists where each node has two pointers pointing to the previous and next nodes.

Array

An array stores data in a sequence. If an array named ‘a’ contains three pieces of data, the brackets next to ‘a’ represent the index of the array.

In an array, you can directly access the data by specifying the index. For example, to access Lemon, you simply specify a[2].
Adding data in an array is more costly than in a list. To add Mango to a[1], for example, first, you need to allocate space at the end of the array.

Then, to make room for the new data, you need to shift the existing data one by one. In this case, you would first move Lemon, then Peach, and finally place Mango at a[1].

To delete data, you reverse the process. For example, to delete Mango, you remove it and then shift Peach and Lemon to the right.
Arrays allow easy access to data, but adding or deleting data can be costly.

Stack

A stack is a data structure that follows the LIFO (Last In, First Out) principle. Data added later is removed first. In a stack, adding data is called “push” and removing data is called “pop.”
For example, if you push Apple and then push Peach, the result would be as follows:

When you pop, Peach is removed.

A stack is useful when you always need access to the most recently added data but doesn’t allow access to intermediate data.

Queue

A queue is a data structure that follows the FIFO (First In, First Out) principle. Data added earlier is removed first. In a queue, adding data is called “enqueue” and removing data is called “dequeue.”
For example, if you enqueue Apple and then enqueue Peach, the result would be as follows:

At this point, it’s similar to a stack. However, when you dequeue, Apple is removed.

A queue, like a stack, doesn’t allow access to intermediate data but is useful when you need to process data in the order it was added.

Hash Table

A hash table is a data structure that uses a hash function to efficiently search for data consisting of key-value pairs. For example, consider storing a [key, value] pair like [Taro, Male] in an array with five boxes.

First, the key “Taro” is converted using the hash function. The result is 3569 (this is called the hash value).

When you apply the modulus operation with 5 (since the array has five boxes), 3569 equals 4. Therefore, [Taro, Male] is stored in the 4th box.

Next, consider the data [Hanako, Female]. When you hash “Hanako” and apply the modulus operation, if the result is 0 to 3, it is stored in the corresponding box. If the result is 4, the data is linked to [Taro, Male] in the same box using a list.

A hash table can quickly retrieve data by using the key.

Conclusion

This time, we introduced some basic data structures such as lists, arrays, stacks, queues, and hash tables. We also touched on their mechanisms and features.
To choose the right data structure for your program, you need to understand the advantages and disadvantages of each one. If you need fast data retrieval and flexibility, hash tables are great, while for sequential processing, lists or arrays may be better. Furthermore, if you need to process data in a specific order, stacks and queues can be useful.
Now that you know the characteristics of different data structures, you can choose the best one according to your needs. Happy coding!