Data Structures

Data structure definition

Definition;
 Data structures are fundamental components of any
software project, as they determine how data is
organized, stored, and accessed. Choosing the right
data structure is critical for optimizing performance,
memory usage, and scalability.
• Using the appropriate data structure helps develop
efficient programs in terms of execution time and
memory usage.
• Choosing the right data structure involves considering
Importance of Data Structures in Software Projects

• Efficient Data Management: They enable efficient

storage, retrieval, and manipulation of data.
• Performance Optimization: Properly chosen data
structures improve the speed and efficiency of algorithms.
• Scalability: They ensure the software can handle
increasing amounts of data without performance
degradation.
• Code Maintainability: Well-structured data makes the
code easier to understand, debug, and maintain.
• Problem-Solving: Different data structures are suited to
different types of problems, enabling developers to choose
the best tool for the task.
 Abstract Data Structures

•Array: A collection of elements accessed using indexes.

Elements are stored in contiguous memory locations
making searching for elements in an array easy. However,
it is harder to insert or delete elements in an array.

1 2 3 4 Elements

0 1 2 3 indexes
Abstract Data Structures

•Linked list: Contains a pointer to the address of the

next element in the list.
•Faster at inserting and deleting elements
•To read from a linked list, you have to search from
the beginning making data access slower.
20 21 100 101
1 100 2 290
Abstract Data Structures

•Hash tables: Similar to arrays but instead uses keys to read

elements.
•Each value is paired with a key to identify and search
elements easily.
Kampala Nairobi Kigali
“Uganda” “Kenya” “Rwanda” keys
 Abstract Data Structures

•Stack: Adds data on top of the pile and accesses it in the order
of Last-In-First-Out (LIFO). Fast for reading, adding and deleting
data.
•Queue: Elements are added at the back of the line and accessed
or removed from the front. Applies First-In-First-Out. For
example in a YouTube mix list, you will first watch the first video
in the list
Abstract Data Structures

•Trees: Hierarchical data structure with a root node and child

nodes. Easy to search data by eliminating values until the
desired element is found e.g. in a guessing game
•Graphs: Nodes can be connected to many nodes. Edges can
be weighted to help estimate closest path between
points. 10
4 B 2
C A
5 5 12
3 1
D Tree
Graph 1 15
 Applications of Data Structures

•Hash tables can be used in a web server to store frequently

requested webpages in cache so that the pages are
quickly accessed.
•Graphs are used to determine the shortest route between a
rider and customer on a SafeBoda App.
•Binary search trees are used when finding a specific record
based on a unique identifier in a guessing game.
•Priority queues are used in Operating systems to
schedule high priority tasks like sorting, searching,
updating data to run quickly.
Common Data Structures and Their Use Cases

1-Arrays
• Description: A collection of elements stored in
contiguous memory locations.
• Use Cases:
• Storing fixed-size data (e.g., pixel values in an
image).
• Implementing matrices or tables.
• Advantages: Fast access using indices.
• Limitations: Fixed size, inefficient for
insertions/deletions.
2- Linked Lists

• Description: A sequence of nodes where each node

points to the next node.
• Use Cases:
• Dynamic memory allocation (e.g., implementing
stacks, queues).
• Applications requiring frequent insertions/deletions
(e.g., undo functionality in text editors).
• Advantages: Dynamic size, efficient
insertions/deletions.
• Limitations: Slower access time compared to arrays.
3. Stacks

• Description: A Last-In-First-Out (LIFO) structure.

• Use Cases:
• Function call management (call stack).
• Undo/redo operations.
• Parsing expressions (e.g., infix to postfix conversion).
• Advantages: Simple and efficient for LIFO operations.
• Limitations: Limited access to elements (only top
element is accessible).
4. Queues

• Description: A First-In-First-Out (FIFO) structure.

• Use Cases:
• Task scheduling (e.g., CPU scheduling).
• Handling requests in web servers.
• Breadth-First Search (BFS) in graphs.
• Advantages: Efficient for FIFO operations.
• Limitations: Limited access to elements (only
front and rear elements are accessible).
5. Trees

• Description: A hierarchical structure with a root

node and child nodes.
• Use Cases:
• Binary Search Trees (BST) for efficient searching,
insertion, and deletion.
• Heaps for priority queues.
• Trie for autocomplete and dictionary
implementations.
• Advantages: Efficient for hierarchical data and
searching.
6. Graphs

• Description: A collection of nodes (vertices) connected

by edges.
• Use Cases:
• Social networks (e.g., Facebook friends).
• Navigation systems (e.g., Google Maps).
• Recommendation systems.
• Advantages: Ideal for modeling relationships and
networks.
• Limitations: High memory usage and complexity.
7. Hash Tables

• Description: A key-value pair storage structure

using hash functions.
• Use Cases:
• Database indexing.
• Caching (e.g., memoization).
• Implementing dictionaries.
• Advantages: Fast lookups, insertions, and
deletions.
• Limitations: Collisions can occur, requiring
handling (e.g., chaining, open addressing).
Choosing the right data structure

 The choice of data structure depends on:

• Type of Data: Structured, semi-structured, or
unstructured.
• Operations Required: Frequent insertions, deletions, or
searches.
• Performance Requirements: Time and space complexity.
• Scalability: Ability to handle growing data sizes.
• Ease of Implementation: Complexity of the data
structure.
Data structures application in a software project

• Databases: B-trees and hash tables for indexing

and searching.
• Web Development: Stacks for managing browser
history, queues for handling API requests.
• Artificial Intelligence: Graphs for neural
networks, trees for decision-making algorithms.
• Operating Systems: Queues for process
scheduling, stacks for memory management.
• Gaming: Graphs for game maps, trees for decision
trees in AI opponents.