Unit I INTRODUCTION

Definition- Classification of data structures: primitive and non-primitive- Operations on data

structures- Algorithm Analysis

Definition of Data Structures:

A data structure is a specialized format for organizing, storing, and managing data. It provides a
way to efficiently access and modify data. In essence, it's a logical or mathematical model of
how data is organized and how it can be manipulated.

Key aspects of a data structure:

●​ Organization: How data elements are arranged and related to each other.
●​ Storage: How data is physically stored in memory.
●​ Operations: The set of operations that can be performed on the data (e.g., insertion,
deletion, searching, sorting).
●​ Efficiency: The performance characteristics of the data structure in terms of time and
space complexity.

Classification of Data Structures:

Data structures can be broadly classified into two main categories:

1.​ Primitive Data Structures:​

○​ These are the basic data structures that are directly supported by the
programming language.
○​ Examples:
■​ Integers (int)
■​ Floating-point numbers (float, double)
■​ Characters (char)
■​ Booleans (bool)
2.​ Non-Primitive Data Structures:​
 ○​ These are more complex data structures that are derived from primitive data
structures.​

○​ They are designed to handle larger and more complex datasets.​

○​ Non-primitive data structures can be further classified into:​

○​ Linear Data Structures:​

■​ Data elements are arranged in a sequential or linear order.

■​ Examples:
■​ Arrays: A collection of elements of the same data type stored in
contiguous memory locations.
■​ Linked Lists: A sequence of nodes, where each node contains
data and a pointer to the next node.
■​ Stacks: A LIFO (Last-In, First-Out) data structure.
■​ Queues: A FIFO (First-In, First-Out) data structure.
○​ Non-Linear Data Structures:​

■​ Data elements are not arranged in a linear order.

■​ They represent hierarchical or network-like relationships between data
elements.
■​ Examples:
■​ Trees: A hierarchical data structure consisting of nodes connected
by edges.
■​ Graphs: A collection of nodes (vertices) and edges that connect
them.
■​ Heaps: specialized tree based data structure.

Key Considerations:

●​ The choice of data structure depends on the specific requirements of the application,
such as the type of data, the operations to be performed, and the performance
requirements.
●​ Understanding the characteristics and trade-offs of different data structures is essential
for efficient software development.

. Primitive Data Structures:

●​ Definition:
○​ These are the most basic data structures that are directly supported by the
programming language.
○​ They represent fundamental data types that the compiler already understands.
○​ They are the building blocks for more complex data structures.
●​ Characteristics:
 ○​ Directly Supported: The language provides built-in mechanisms for creating
and manipulating these data types.
○​ Fixed Size: Typically, they have a fixed size in memory.
○​ Simple Operations: Operations on primitive data types are usually simple and
efficient.
●​ Examples:
○​ Integer (int): Represents whole numbers (e.g., 10, -5, 0).
○​ Floating-Point (float, double): Represents numbers with decimal points (e.g.,
3.14, -2.5). double offers higher precision.
○​ Character (char): Represents single characters (e.g., 'A', '7', '$').
○​ Boolean (bool): Represents logical values (true or false).
●​ Purpose:
○​ They are used to store basic data values.
○​ They are used as the foundation for creating more complex data structures.

2. Non-Primitive Data Structures:

●​ Definition:
○​ These are data structures that are derived from primitive data structures.
○​ They are designed to handle larger and more complex datasets.
○​ They are created by programmers to organize collections of primitive or other
non-primitive data.
●​ Characteristics:
○​ Derived: They are built using primitive data types or other non-primitive data
structures.
○​ Flexible Size: They can have varying sizes, and their size can change during
program execution.
○​ Complex Operations: Operations on non-primitive data structures can be more
complex and involve algorithms.
●​ Types:
○​ Linear Data Structures:
■​ Data elements are arranged in a sequential or linear order.
■​ Examples:
■​ Arrays: A collection of elements of the same data type stored in
contiguous memory locations.
■​ Linked Lists: A sequence of nodes, where each node contains
data and a pointer to the next node.
■​ Stacks: A LIFO (Last-In, First-Out) data structure.
■​ Queues: A FIFO (First-In, First-Out) data structure.
○​ Non-Linear Data Structures:
■​ Data elements are not arranged in a linear order.
■​ They represent hierarchical or network-like relationships between data
elements.
■​ Examples:
 ■​ Trees: A hierarchical data structure consisting of nodes connected
by edges.
■​ Graphs: A collection of nodes (vertices) and edges that connect
them.
■​ Heaps: specialized tree based data structure.
●​ Purpose:
○​ They are used to organize and manage large and complex datasets.
○​ They are used to implement complex algorithms and data processing tasks.
○​ They are used to model real world relationships between data.

Key Differences Summarized:

●​ Basis: Primitive are fundamental, non-primitive are derived.

●​ Support: Primitive are built-in, non-primitive are user-defined.
●​ Complexity: Primitive are simple, non-primitive are complex.
●​ Size: Primitive are fixed, non-primitive are flexible.

Operations on Data Structures:

Data structures are not just about storing data; they're also about performing operations on that
data efficiently. Common operations include:

1.​ Traversal:
○​ Visiting each element in the data structure exactly once.
○​ Example: Printing all elements of an array or linked list.
2.​ Insertion:
○​ Adding a new element to the data structure.
○​ Example: Adding a node to a linked list or pushing an element onto a stack.
3.​ Deletion:
○​ Removing an element from the data structure.
○​ Example: Removing a node from a linked list or popping an element from a stack.
4.​ Searching:
○​ Finding a specific element in the data structure.
○​ Example: Searching for a value in an array or a node in a tree.
5.​ Sorting:
○​ Arranging the elements in a specific order (e.g., ascending or descending).
○​ Example: Sorting an array of numbers.
6.​ Merging:
○​ Combining two or more data structures into a single data structure.
○​ Example: Merging two sorted linked lists.
7.​ Splitting:
○​ Dividing a data structure into multiple data structures.
○​ Example: Splitting a linked list into two separate lists.
Algorithm Analysis:

Algorithm analysis is the process of evaluating the efficiency of an algorithm. It helps us

understand how an algorithm's performance scales with the size of the input.

Key aspects of algorithm analysis:

1.​ Time Complexity:

○​ Measures the amount of time an algorithm takes to execute as a function of the
input size.
○​ Expressed using Big O notation (e.g., O(n), O(log n), O(n^2)).
○​ Focuses on the dominant term and ignores constant factors and lower-order
terms.
2.​ Space Complexity:
○​ Measures the amount of memory an algorithm uses as a function of the input
size.
○​ Also expressed using Big O notation.
○​ Considers both auxiliary space (extra space used by the algorithm) and input
space.
3.​ Big O Notation:
○​ A mathematical notation used to describe the asymptotic behavior of an
algorithm.
○​ Provides an upper bound on the growth rate of the algorithm's time or space
complexity.
○​ Common Big O complexities:
■​ O(1): Constant time (or space).
■​ O(log n): Logarithmic time.
■​ O(n): Linear time.
■​ O(n log n): Linearithmic time.
■​ O(n^2): Quadratic time.
■​ O(2^n): Exponential time.

Why Algorithm Analysis is Important:

●​ Choosing the Right Algorithm: It helps in selecting the most efficient algorithm for a
given task.
●​ Predicting Performance: It allows us to predict how an algorithm will perform with large
inputs.
●​ Optimizing Code: It helps identify bottlenecks and areas for optimization.
●​ Resource Management: It provides insights into the resource requirements of an
algorithm.

Example:

●​ Linear Search:
 ○​ Time complexity: O(n) (in the worst case).
○​ Space complexity: O(1) (assuming the input array is already in memory).
●​ Binary Search:
○​ Time complexity: O(log n) (for a sorted array).
○​ Space complexity: O(1) (iterative) or O(log n) (recursive).