Empowering The Future Today

Introduction to Algorithms

NWS & SWE 2024/2025

Semester: Fall 2024.

Lecturer: Engr Mbachan Fabrice .T

Email: mbachan.fabrice@yibs.org
Msc in Security and Network Engineering @innopolis
University, Russia.
Introduction to Algorithms: The Building Blocks of Computer
Science
 What is an Algorithm?

● A step-by-step procedure for solving a

problem or accomplishing a task
● Finite sequence of well-defined
instructions
● Can be expressed in various forms
(pseudocode, flowcharts, programming
languages)
● What algorithms do you encounter in
your daily life?
 Characteristics of a Good Algorithm
● Input: Well-defined inputs
● Output: Desired result after following the steps
● Definiteness: Clear and unambiguous instructions
● Finiteness: Terminates after a finite number of steps
● Effectiveness: Feasible operations that can be done in finite
time
Importance of Algorithms in Computer Science

● Foundation of all computer programs and

software
● Enable efficient problem-solving and data
manipulation
● Critical for optimizing performance and
resource utilization
● Essential for advancing technology and
innovation
● How do you think algorithms impact the
apps you use daily?
 Real-world Applications of Algorithms

● Search engines (e.g., Google's PageRank)

● Social media feed recommendations
● GPS navigation and route optimization
● Data compression and encryption
● Machine learning and artificial intelligence
 Basic Algorithm Design
Techniques
● Divide and Conquer
● Greedy Algorithms
● Dynamic Programming
● Backtracking
● Can you think of a problem that might use
one of these techniques?
 Divide and Conquer
● Break problem into smaller subproblems
● Solve subproblems recursively
● Combine solutions to solve the original
problem
● Examples: Merge Sort, Quick Sort, Binary
Search
 Greedy Algorithms
● Make locally optimal choice at each step
● Hope to find global optimum
● May not always produce the best solution
● Examples: Huffman Coding, Dijkstra's Algorithm
● When might a greedy approach fail?
Dynamic Programming

● Solve complex problems by breaking them

into simpler subproblems
● Store results of subproblems to avoid
redundant calculations
● Optimize recursive algorithms
● Examples: Fibonacci sequence, Longest
Common Subsequence
 Backtracking
● Build solution incrementally
● Abandon partial solutions that cannot
lead to a valid result
● Systematically explore all possible
solutions
● Examples: N-Queens Problem, Sudoku
Solver
● How might backtracking be used in a
game like chess?
 Algorithm Analysis

● Evaluating algorithm efficiency and

performance
● Time complexity: How runtime grows
with input size
● Space complexity: How memory usage
grows with input size
● Big O notation for expressing upper
bounds
● Why is algorithm analysis important in
software development?
 Time Complexity Classes
● O(1): Constant time
● 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
 Time Complexity Classes
1. O(1): Constant Time 2. O(log n): Logarithmic Time

● Description: The runtime grows logarithmically as the input size

● Description: The runtime does not depend
increases, meaning that the algorithm cuts the problem size in half at
on the size of the input; it remains constant
each step.
regardless of input size.
● Example: Binary search on a sorted array.
● Example: Accessing an element in an array
● Binary search reduces the search space by half each time, resulting in
by in
logarithmic time complexity.
●
 Time Complexity Classes
4. O(n log n): Linearithmic Time

3. O(n): Linear Time ● Description: The runtime is a combination of linear and logarithmic
factors. Algorithms with this complexity are typically more efficient
● Description: The runtime grows linearly with than O(n²) but less efficient than O(n).
the input size, meaning that the time taken ● Example: Merge Sort, Quick Sort (in average case).
increases directly in proportion to the number ● Merge sort divides the array into halves (log n splits) and then
of elements. merges the results (n operations), resulting in a time complexity of
● Example: Iterating over an array to find the O(n log n).
maximum element.
● The algorithm must examine each element in
the array, so the runtime is proportional to
the number of elements (n).
●
 Time Complexity Classes
6. O(2ⁿ): Exponential Time

5. O(n²): Quadratic Time ● Description: The runtime doubles with each additional element in
the input. These algorithms are extremely inefficient for large inputs.
● Description: The runtime grows ● Example: Solving the Tower of Hanoi problem or calculating the nth
quadratically with the input size, meaning Fibonacci number using a naive recursive approach.
that the time taken is proportional to the
square of the number of elements. This is The recursive Fibonacci algorithm recalculates values repeatedly, leading
typical for algorithms that involve nested to exponential growth in the number of recursive calls as n increases.
loops.
● Example: Selection Sort or Bubble Sort.
● For every element, the algorithm compares it
to every other element, resulting in O(n²)
comparisons.
 Space-Time Tradeoff
● Balancing memory usage and execution time
● Sometimes faster algorithms require more memory
● Example: Hash tables vs. Arrays for data lookup
● Can you think of a situation where you'd prioritize space over
time?
Algorithm Correctness

● Ensuring the algorithm always produces

the correct output
● Techniques: Mathematical proofs,
Induction, Loop invariants
● Testing: Unit tests, Edge cases, Stress
testing
● Why is proving correctness crucial in
critical systems?
 Sorting Algorithms
● Arranging elements in a specific order (e.g., ascending,
descending)
● Common algorithms: Bubble Sort, Selection Sort, Insertion Sort
● More efficient algorithms: Merge Sort, Quick Sort, Heap Sort
● How might the choice of sorting algorithm affect a large database
system?
 Searching Algorithms

● Finding a specific element in a collection

of data
● Linear Search: O(n) time complexity
● Binary Search: O(log n) time complexity
(requires sorted data)
● Hash-based Search: O(1) average case
(with good hash function)
 Graph Algorithms
● Solving problems related to graph structures
● Breadth-First Search (BFS) and Depth-First Search (DFS)
● Shortest path algorithms (e.g., Dijkstra's, Bellman-Ford)
● Minimum Spanning Tree algorithms (e.g., Kruskal's, Prim's)
● How might social networks use graph algorithms?
Parallel and Distributed
Algorithms

● Designed to run on multiple processors or

computers
● Divide work among different units of
computation
● Challenges: Synchronization, load
balancing, fault tolerance
● Examples: MapReduce, Parallel sorting
algorithms
 Machine Learning Algorithms
● Enable computers to learn from data without explicit
programming
● Supervised Learning: Classification, Regression
● Unsupervised Learning: Clustering, Dimensionality Reduction
● Reinforcement Learning: Q-learning, Policy Gradient methods
● How do you think ML algorithms differ from traditional
algorithms?
 Algorithmic Problem-Solving Strategies

● Understand the problem thoroughly

● Break down complex problems into smaller, manageable parts
● Choose appropriate data structures
● Consider multiple approaches before implementation
● Optimize and refine your solution
 The Future of
Algorithms
● Quantum algorithms for quantum
computers
● Neuromorphic computing algorithms
● Advanced AI and machine learning
algorithms
● Algorithms for big data and edge
computing
● What new types of algorithms do you think
we'll need in the future?
 What are Flowcharts?

● Visual representations of algorithms or

processes
● Use standardized symbols connected by
arrows
● Show step-by-step flow of operations
● Help visualize logic and decision points
● How might flowcharts be useful in your
daily life?
Key Flowchart
Symbols
● Oval: Start/End
● Rectangle: Process or Action
● Diamond: Decision
● Parallelogram: Input/Output
● Arrow: Flow Direction
● Can you think of a simple process to
represent with these symbols?
 Benefits of Using Flowcharts
● Improve understanding of complex processes
● Identify bottlenecks and inefficiencies
● Facilitate communication between team members
● Aid in troubleshooting and problem-solving
● How might flowcharts help in group projects?
 Creating Effective Flowcharts
● Keep it simple and clear
● Use consistent symbol sizes
● Ensure logical flow from top to bottom, left to right
● Label decision points clearly
● Use short, descriptive phrases in symbols
● What challenges might you face when creating a flowchart?
 Flowchart Example:
Making Tea
● Start: Begin process
● Boil water
● Decision: Is water boiling?
● Add tea bag to cup
● Pour hot water into cup
● Wait for tea to steep
● Remove tea bag
● End: Enjoy your tea
● Can you create a flowchart for a different
everyday task?
 Introduction to Pseudocode
● Informal, structured description of an algorithm
● Uses plain language and simple syntax
● Bridge between human thinking and programming languages
● Not tied to any specific programming language
● How might pseudocode help you plan a coding project?
 Pseudocode vs. Programming Languages

● Pseudocode: Informal, flexible, human-readable

● Programming languages: Formal syntax, strict rules
● Pseudocode focuses on logic and structure
● Programming languages are executable by computers
● Why might you use pseudocode before writing actual code?
 Key Elements of Pseudocode
● Input/Output statements
● Assignment operations
● Conditional statements (IF-THEN-ELSE)
● Looping structures (FOR, WHILE)
● Function or procedure calls
● Can you identify these elements in a simple algorithm you know?
 Writing Effective Pseudocode
● Use clear, concise language
● Maintain consistent level of detail
● Include all necessary steps and decisions
● Use indentation to show structure
● Avoid language-specific syntax
● What style choices might you make when writing pseudocode?
 Pseudocode Example: Finding Maximum Number

● BEGIN
● Input numbers A, B, C
● IF A > B AND A > C THEN
● max = A
● ELSE IF B > A AND B > C THEN
● max = B
● ELSE
● max = C
● END IF
● Output max
● END
● Can you modify this pseudocode to find the minimum number?
 Combining Flowcharts and Pseudocode

● Use flowcharts for high-level overview

● Use pseudocode for detailed logic within steps
● Flowcharts provide visual structure
● Pseudocode offers more detailed instructions
● How might using both improve your algorithm design process?
 Flowcharts in Software Development

● Used in planning and design phases

● Help visualize system architecture
● Useful for documenting complex processes
● Aid in identifying potential issues early
● In what other fields might flowcharts be valuable?
 Pseudocode in Programming Practice

● Used to plan code structure before implementation

● Helps focus on logic without syntax concerns
● Useful for communicating algorithms to team members
● Can be easily translated into various programming languages
● How might pseudocode help in learning a new programming
language?
Tools for Creating
Flowcharts
● Microsoft Visio
● Lucidchart
● Draw.io
● SmartDraw
● Creately
● Have you used any of these tools? What
was your experience?
 Best Practices for Algorithm Design
● Start with a clear problem statement
● Break down complex problems into smaller steps
● Use flowcharts for overall structure
● Develop detailed pseudocode for each step
● Review and refine your design iteratively
● How might these practices improve your coding projects?
 Common Pitfalls in Flowchart Design
● Over Complicated diagrams
● Inconsistent use of symbols
● Unclear decision points
● Poor layout and readability
● Missing start or end points
● How can you avoid these issues in your flowcharts?
 Improving Pseudocode Clarity
● Use descriptive variable names
● Comment on complex logic
● Keep statements simple and focused
● Use consistent terminology
● Clearly define inputs and outputs
● What strategies do you use to make your code more readable?
 Flowcharts and Pseudocode in Team Collaboration

● Facilitate communication of ideas

● Provide common ground for discussion
● Help identify potential issues early
● Enable division of tasks in complex projects
● How might these tools improve group coding projects?
 From Design to Implementation
● Use flowcharts and pseudocode as blueprints
● Translate pseudocode into actual code
● Refer to flowcharts for overall structure
● Test implementation against original design
● Iterate and refine as needed
● What challenges might you face in this translation process?
 The Future of Algorithm Design Tools

● AI-assisted flowchart and pseudocode generation

● Interactive and collaborative online platforms
● Integration with version control systems
● Automated code generation from pseudocode
● How do you think these advancements might change
programming?