Fundamental Terminologies

Some fundamental terminologies used

whenever the data structures are involved:
1. Data: We can define data as an
elementary value or a collection of
values. For example, the Employee's
name and ID are the data related to the
Employee.
2. Data Items: A Single unit of value is
known as Data Item.
3. Group Items: Data Items that have
subordinate data items are known as
Group Items. For example, an
employee's name can have a first,
middle, and last name.
4. Elementary Items: Data Items that
are unable to divide into sub-items are
known as Elementary Items. For
example, the ID of an Employee.
5. Entity and Attribute: A class of
certain objects is represented by an
Entity. It consists of different Attributes.
Each Attribute symbolizes the specific
property of that Entity. For example,
6.

Attribute ID Nam Gende Job Title

s e r
Values 123 Stac Femal Softwar
4 ey e e
M. Develop
Hill er

Entities with similar attributes form

an Entity Set. Each attribute of an entity
set has a range of values, the set of all
possible values that could be assigned to
the specific attribute.
The term "information" is sometimes utilized
for data with given attributes of meaningful
or processed data.
1. Field: A single elementary unit of
information symbolizing the Attribute of
an Entity is known as Field.
2. Record: A collection of different data
items are known as a Record. For
example, if we talk about the employee
entity, then its name, id, address, and
job title can be grouped to form the
record for the employee.
3. File: A collection of different Records
of one entity type is known as a File. For
example, if there are 100 employees,
there will be 25 records in the related
 file containing data about each
employee.
Understanding the Need for Data Structures
As applications are becoming more complex
and the amount of data is increasing every
day, which may lead to problems with data
searching, processing speed, multiple
requests handling, and many more. Data
Structures support different methods to
organize, manage, and store data efficiently.
With the help of Data Structures, we can
easily traverse the data items. Data
Structures provide Efficiency, Reusability,
and Abstraction.
Why should we learn Data Structures?
1. Data Structures and Algorithms are
two of the key aspects of Computer
Science.
2. Data Structures allow us to organize
and store data, whereas Algorithms
allow us to process that data
meaningfully.
3. Learning Data Structures and
Algorithms will help us become better
Programmers.
4. We will be able to write code that is
more effective and reliable.
 5. We will also be able to solve
problems more quickly and efficiently.
Understanding the Objectives of Data Structures
Data Structures satisfy two complementary
objectives:
1. Correctness: Data Structures are
designed to operate correctly for all
kinds of inputs based on the domain of
interest. In order words, correctness
forms the primary objective of Data
Structure, which always depends upon
the problems that the Data Structure is
meant to solve.
2. Efficiency: Data Structures also
requires to be efficient. It should process
the data quickly without utilizing many
computer resources like memory space.
In a real-time state, the efficiency of a
data structure is a key factor in
determining the success and failure of
the process.
Understanding some Key Features of Data
Structures
Some of the Significant Features of Data
Structures are:
1. Robustness: Generally, all
computer programmers aim to produce
software that yields correct output for
every possible input, along with efficient
execution on all hardware platforms.
This type of robust software must
manage both valid and invalid inputs.
2. Adaptability: Building software
applications like Web Browsers, Word
Processors, and Internet Search Engine
include huge software systems that
require correct and efficient working or
execution for many years. Moreover,
software evolves due to emerging
technologies or ever-changing market
conditions.
3. Reusability: The features like
Reusability and Adaptability go hand in
hand. It is known that the programmer
needs many resources to build any
software, making it a costly enterprise.
However, if the software is developed in
a reusable and adaptable way, then it
can be applied in most future
applications. Thus, by executing quality
data structures, it is possible to build
reusable software, which appears to be
cost-effective and timesaving.