An Overview of

Data Structures
and Algorithms

WMSU

1
 DATA STRUCTURES
AND
ALGORITHM
Data structures and algorithms are fundamental
concepts in computer science that work
together to efficiently manage and process
information.

2
 DATA STRUCTURES
• A data structure is a specific way of
organizing and storing data in a computer
so that it can be accessed and modified
efficiently. It's essentially a blueprint for
how information is arranged and managed
within a program. Think of it as a
container that holds data in a structured
manner, allowing for various operations to
be performed on that data
3
 Key aspects of data structures:
• Data values: The actual information being
stored.
• Relationships: How the data values are
connected to each other.
• Operations: Functions or procedures that
can be applied to the data, such as
adding, deleting, searching, or sorting.

4
 Types of Data Structures:
Data structures can be broadly categorized
into two main types

• Primitive Data Structures

• Abstract Data Structures

5
 PRIMITIVE DATA STRUCTURES
• Primitive data structures are the
fundamental building blocks of
programming languages. They represent
simple values that are directly supported
by the programming language itself. These
data types are predefined and typically
have a fixed size and range of values.

6
• Integers: Whole numbers (e.g., 5, -10).
• Floats: Real numbers with decimal points
(e.g., 3.14, -2.5).
• Characters: Single letters or symbols (e.g.,
'A', '$').
• Booleans: True or False values.

7
 ABSTRACT DATA STRUCTURES
• An abstract data structure (ADS) is a
conceptual model that defines the logical
structure and behavior of a data collection,
without specifying the underlying
implementation details. It focuses on what
the data structure does, rather than how it
is implemented.

8
 ABSTRACT DATA STRUCTURES
Arrays:

- Arrays are a collection of elements stored in contiguous memory locations.

- Elements are accessed using an index.
- Fixed size in most programming languages.

Linked Lists:

- Linked lists consist of nodes where each node contains data and a reference or pointer to the next node in the
sequence.
- Different types include singly linked lists, doubly linked lists, and circular linked lists.

Stacks:

- Stacks follow the Last-In-First-Out (LIFO) principle.

- Operations include push (add an element) and pop (remove the top element).

Queues:

- Queues follow the First-In-First-Out (FIFO) principle.

- Operations include enqueue (add an element) and dequeue (remove the front element).

Trees:

- Trees are hierarchical data structures with a root node and child nodes. 9
- Types include binary trees, binary search trees, AVL trees, and more.
Graphs:

- Graphs consist of vertices/nodes connected by edges.

- Represent relationships between entities.
- Types include directed graphs, undirected graphs, weighted graphs, etc.

Hash Tables:

- Hash tables store key-value pairs using a hashing function.

- Provide efficient insertion, deletion, and retrieval of data.

Heaps:

- Heaps are complete binary trees that satisfy the heap property.
- Types include min heap and max heap.

Tries:

- Tries are tree-like data structures used for storing a dynamic set of strings.
- Efficient for searching words in a dictionary. 10
Priority Queues:

- Priority queues are data structures that store elements along with their
priorities.
- Elements with higher priorities are dequeued first.

Disjoint Sets:

- Disjoint sets data structure maintains a collection of disjoint sets and

supports operations like union and find.

Matrices:

- Matrices are 2D arrays used to represent tabular data or grids.

- Commonly used in mathematical and graphical applications.
11
 What are Algorithms?

An algorithm is a set of well-defined

instructions or steps that solve a specific
problem or achieve a particular goal. It's a
recipe for how to perform a task, typically
using a sequence of operations.

12
 Key properties of algorithms:
• Unambiguous: Each step is clearly
defined and leaves no room for
interpretation.

• Finite: The algorithm must terminate after

a finite number of steps.

• Effective: Each step can be carried out in

a finite amount of time.
13
 Types of Algorithms:
Algorithms are designed to solve various problems, and they can be
categorized based on their approach:
• Search Algorithms: Finding specific elements within a data structure.
Examples include linear search and binary search.

• Sorting Algorithms: Arranging elements in a specific order (ascending or

descending). Examples include bubble sort, insertion sort, and merge
sort.

• Graph Algorithms: Solving problems on graphs, such as finding the

shortest path between two nodes or determining if a graph is connected.

• Dynamic Programming Algorithms: Breaking down a problem into

overlapping subproblems and storing the solutions to avoid redundant
calculations.

• Greedy Algorithms: Making locally optimal choices at each step, hoping

14
 IMPORTANCE OF ALGORITHM IN
PROBLEM SOLVING
Systematic Approach:

• Breaking Down Complexity: Algorithms

break down complex problems into
smaller, manageable steps. This makes
the problem easier to understand and
solve.
• Clear Instructions: Each step in an
15
Efficiency and Optimization:

• Resource Management: Algorithms help us

optimize the use of resources, such as time and
memory. By choosing the right algorithm, we can
solve problems faster and with less
computational overhead.

• Scalability: As problems grow in size and

complexity, efficient algorithms become crucial.
They ensure that solutions remain practical and
cost-effective even when dealing with large 16
Automation and Reusability:

• Automating Tasks: Algorithms allow us to

automate tasks, freeing up human effort and
increasing productivity. This is especially
valuable for repetitive or complex tasks that
would be time-consuming to perform manually.

• Generalizability: Well-designed algorithms

can be applied to solve a wide range of
problems, making them reusable across 17
Analytical Thinking and Problem-Solving
Skills:

• Developing Logical Thinking: Understanding

and implementing algorithms requires
developing structured thinking and reasoning
abilities, which are valuable skills in various
fields.

• Problem Decomposition: Algorithms

encourage us to break down problems into
smaller, more manageable components, which is18
Real-World Applications:

• Everywhere We Look: Algorithms are at

the heart of many technologies we use
daily, from search engines and social
media platforms to GPS navigation and
medical diagnosis.

• Driving Innovation: Algorithms are

driving innovation in various fields,
19
including artificial intelligence, machine
 Why are Data Structures and
Algorithms Important?
Efficiency: They allow for efficient storage, retrieval,
and manipulation of data, especially when dealing
with large datasets.

• Scalability: They enable programs to handle

increasing amounts of data without significant
performance degradation.

• Problem Solving: They provide a systematic

framework for solving complex problems in a
structured and efficient manner. 20
• Code Optimization: They help write
optimized and performant code, leading to
faster execution times and reduced
resource consumption.

• Foundation for Advanced Concepts:

They form the foundation for many
advanced computer science concepts,
such as data mining, machine learning, and
21
 Data Structures and Algorithms
Working Together

Data structures and algorithms are

inseparable. Algorithms often operate on
data structures, and the choice of data
structure can significantly impact the
efficiency of an algorithm. For example, a
binary search algorithm works efficiently on
a sorted array, but it wouldn't be suitable for
an unsorted linked list. 22
 Learning Data Structures and
Algorithms
Learning DSA is essential for anyone
pursuing a career in software development.
It's a valuable skill that opens doors to
various opportunities and allows you to build
robust and efficient software applications.

23
 Overview of
Data
Structures
and
WMSU Algorithms

24
 Data Structures: Organizing and
Storing Data
Data structures are a systematic way to
organize and store data in a computer's
memory, enabling efficient access and
manipulation. They provide a blueprint for
how data is arranged and how relationships
between data elements are represented.

25
Interface: Defining the Operations
The interface of a data structure defines the
set of operations that can be performed on
it. It acts as a contract, specifying the
available functionalities and their expected
behavior. The interface doesn't reveal the
internal details of how the data is stored or
how the operations are implemented.

26
For example, the interface of a stack data
structure might include operations like:

push: Adds an element to the top of the stack.

pop: Removes the top element from the stack.

peek: Returns the top element without removing

it.
isEmpty: Checks if the stack is empty.
27
Implementation: The Internal
Details
The implementation of a data structure provides the
internal details of how the data is stored and how
the operations defined in the interface are actually
executed. It specifies the underlying data
representation and the algorithms used for each
operation.

For instance, a stack could be implemented using

an array or a linked list. The choice of
implementation affects the performance
characteristics of the data structure, such as the
time complexity of different operations. 28
 Introduction
to Python
Programmin
g Language
WMSU

29
 What is Python?
Python is a popular programming language.
It was created by Guido van Rossum, and
released in 1991.
• It is used for:
• web development (server-side)
• software development
• mathematics
• system scripting.
30
 What can Python do?
• Python can be used on a server to create web
applications.
• Python can be used alongside software to create
workflows.
• Python can connect to database systems. It can
also read and modify files.
• Python can be used to handle big data and
perform complex mathematics.
• Python can be used for rapid prototyping, or for
production-ready software development.
31
 Why Python?
• Python works on different platforms (Windows, Mac, Linux,
Raspberry Pi, etc).
• Python has a simple syntax similar to the English language.
• Python has syntax that allows developers to write programs
with fewer lines than some other programming languages.
• Python runs on an interpreter system, meaning that code
can be executed as soon as it is written. This means that
prototyping can be very quick.
• Python can be treated in a procedural way, an object-
oriented way or a functional way.

32
Python Syntax compared to other
programming languages
• Python was designed for readability, and
has some similarities to the English
language with influence from mathematics.
• Python uses new lines to complete a
command, as opposed to other
programming languages which often use
semicolons or parentheses.
• Python relies on indentation, using
whitespace, to define scope; such as the
scope of loops, functions and classes. 33
BASIC PYTHON
SYNTAX:

34
Python is a versatile programming language
known for its simplicity and readability. Here
are some basic syntax rules in Python:

1. Comments:
- Comments start with the # symbol and
are used to explain code. They are ignored
by the Python interpreter.

35
2. Variables:
- Variables are used to store data values.
- Variable names are case-sensitive and
must start with a letter or an underscore.

36
3. Data Types:
- Python has various data types including
integers, floats, strings, lists, tuples,
dictionaries, etc.

37
4. Print Statement:

- The print() function is used to display

output.

38
5. Indentation:

- Python uses indentation to define code

blocks.

39
6. Conditional Statements:

- if , elif , and else are used for decision-

making.

40
7. Loops:

- for and while loops are used for iteration.

41
8. Functions:

- Functions are defined using the def

keyword.

42
 g data
structures and
algorithms
through
Python
WMSU

43
 Implementing Data Structures in
Python:
1. Lists:

• - Python lists are versatile and can be used to implement

dynamic arrays.
• - Practice operations like append, pop, insert, and slicing.
2. Dictionaries:

• - Python dictionaries are key-value pairs and can be used

to implement hash tables.
• - Experiment with dictionary operations like adding,
accessing, and deleting key-value pairs.
44
3. Linked Lists:

• - Implement singly linked lists, doubly linked lists, or circular linked lists in Python.
• - Practice operations like insertion, deletion, and traversal.
• 4. Stacks and Queues:

• - Implement stacks and queues using Python lists or linked lists.

• - Practice operations like push, pop, enqueue, and dequeue.
5. Trees:

• - Implement binary trees, binary search trees, or other tree structures in Python.
• - Practice tree traversal algorithms such as in-order, pre-order, and post-order
traversal.
6. Graphs:

• - Implement graphs using adjacency lists or adjacency matrices in Python.

• - Practice graph traversal algorithms like depth-first search (DFS) and breadth-
first search (BFS).

45
 Implementing Algorithms in
Python:
1. Sorting Algorithms:

• - Implement classic sorting algorithms like bubble sort, selection

sort, insertion sort, merge sort, and quicksort in Python.
• - Compare their performance and understand their time
complexity.
2. Searching Algorithms:

• - Implement linear search and binary search algorithms in

Python.
• - Understand their differences in terms of time complexity and
efficiency.

46
3. Recursion:

• - Implement recursive functions in Python for tasks like

factorial calculation or Fibonacci sequence generation.
• - Understand the concept of recursion and how it can be
used in algorithms.
4. Dynamic Programming:

• - Implement dynamic programming solutions to classic

problems in Python, such as the Fibonacci series or the
knapsack problem.
• - Understand how dynamic programming can optimize
solutions by breaking down problems into smaller
subproblems.
47
 Thank you
WMSU

48