Contents

Basic Algorithms with Pseudocode and Flowcharts using "Lucidchart" ................................................. 2

Algorithmic Thinking and Pseudocode: Understanding the Essentials .................................................. 5
Designing Flowcharts for Sorting Algorithms ......................................................................................... 7
Algorithmic Problem Solving ................................................................................................................... 9
1. Problem Analysis for Algorithmic Solutions .................................................................................... 9
2. Implementing Search Algorithms ................................................................................................... 9
3. Writing and Visualizing Search Algorithms ............................................................................... 10
Advanced Algorithms and Efficiency: ................................................................................................... 12
Exploring Recursion with Fibonacci and Factorial ............................................................................ 12
Recursive Magic: Understanding the Concept ...................................................................... 12
The Fibonacci Sequence ................................................................................................................ 12
Time Complexity ......................................................................................................................... 12
Factorial Calculation:..................................................................................................................... 13
Alternative Approaches .................................................................................................................... 13
Understanding Big O Notation .......................................................................................................... 17
Common Notations: ...................................................................................................................... 17
Calculating Big O notation............................................................................................................. 18
Basic Algorithms with Pseudocode and Flowcharts using "Lucidchart"

Lucidchart is a web-based diagramming application that allows users to visually collaborate on

drawing, revising and sharing charts and diagrams, and improve processes, systems, and
organizational structures.

Lucidchart is entirely browser-based, running on browsers that support HTML5. This means it does
not require plugins or updates of a third-party software like Adobe Flash. The platform supports real-
time collaboration, allowing all users to work simultaneously on projects and see each user’s
additions reflected in real [Link] data is encrypted and stored in secure data centers.

Additional features include:

 A drag-and-drop interface
 Real-time co-authoring, shape-specific comments, and collaborative cursors
 Data linking
 Auto-visualization to generate org charts and ERDs
 SQL import and export capabilities

Getting started with Lucidchart

Before you begin, you’ll want to set up an account with Lucidchart. It’s free for all first-time users
and also free for educators and students when you sign up using your school email address.

Once you’re signed up and have an account, no matter where you are on the [Link] website,
you can access the editor and your documents by clicking on the Log In button in the upper right
corner which will then display as Documents when you’re actually logged in.

How to make a flowchart

1. Once you’re in the Lucidchart editor, you can choose to start with an existing flowchart template
from our template library that you can then proceed to customize or you can start with a blank
canvas and make a flowchart from scratch.

2. Click on any shape, drag it onto the editor, and drop it in for placement. You can input whatever
info you want including images, animations, and links.

3. To connect shapes, click on the red outlined white dot on any shape and drag a line out to connect
or point to your desired location or shape.
When you’re done making your flowchart, you can share it with anyone and customize the settings
by clicking the Share button in the upper right corner.

You can also publish it in any format when you go to File > Download As or File > Publish.

How to format your flowchart

Edit Shapes

You can customize each and every shape one by one or as a group in Lucidchart. To edit a single
shape, click on it and enhance or reduce it to the desired size.

Change the color by selecting a shade from the Fill Color icon in the top toolbar or select a pre-made
Theme from the right menu.

That top toolbar features tools that will allow the option to edit nearly every aspect of your shapes,
lines, and text.

Edit Lines

Select any line you’d like to customize and then make your way over to the top toolbar to customize
the thickness, line style, even arrow style for your lines.
You can select a single item on your canvas and edit it, but if you click to hold and then select a
section or area, you’ll find that you’ve highlighted all the objects within that area and whatever
movements or customizations you choose will apply to all the items in that highlighted section.

Mistakes might happen when you’re making your flowchart, but you won’t have to do much
reformatting or start all over if things start to get messy.

If you ever need to undo your last action, a simple Ctrl+Z shortcut will work. You can also view the
entire revision history in the right sidebar under History and restore your current diagram to any
previous revision you select.
Algorithmic Thinking and Pseudocode: Understanding the Essentials
Algorithmic thinking and pseudocode are fundamental concepts in computer science
that go hand-in-hand. Let's break down each concept and explore their relationship:

Algorithmic Thinking:

 It's a problem-solving approach that involves breaking down a complex task into smaller,
step-by-step instructions that can be followed by a computer.

 It focuses on the logic and sequence of steps needed to achieve a desired outcome.

 Imagine it like a recipe - a clear set of instructions that guide you through a process.

Pseudocode:

 It's a way to represent an algorithm in a human-readable format, using plain English with
some programming-like keywords.

 It's not an actual programming language but a tool to communicate the logic of an
algorithm before writing actual code.

 Think of it as a draft of the recipe, outlining the steps without the specific measurements
or technical jargon.

Benefits of Algorithmic Thinking and Pseudocode:

 Improved Problem-Solving: By breaking down problems into steps, you can develop a
clear understanding of how to solve them.

 Enhanced Communication: Pseudocode allows you to explain algorithms to others in a

clear and concise way.

 Easier Coding: Once you have a well-defined algorithm in pseudocode, translating it

into actual code becomes much simpler.

Relationship Between Them:

1. Problem Identification: You start with a problem that needs to be solved.

2. Algorithmic Thinking: You use algorithmic thinking to break down the problem into
smaller, logical steps.
3. Pseudocode Creation: You express those steps in a clear and organized way using
pseudocode.
4. Code Implementation: Finally, you translate the pseudocode into an actual
programming language to create a working program.

Example: Finding the Largest Number

Problem: Write an algorithm to find the largest number among three given numbers.
Pseudocode:

DECLARE num1, num2, num3 (numeric) ; Input variables for the three numbers
DECLARE largest (numeric) ; Output variable to store the largest number

; Get the three numbers from the user (replace with actual input method in
real code)
READ num1, num2, num3

; Initialize largest with the first number

SET largest = num1

; Check if the second number is larger

IF num2 > largest THEN
SET largest = num2
END IF

; Check if the third number is larger

IF num3 > largest THEN
SET largest = num3
END IF

; Print the largest number

PRINT "The largest number is:", largest

Algorithmic thinking provides the foundation for solving problems with computers,
and pseudocode acts as a bridge between human understanding and computer
code. By mastering these concepts, you'll be well on your way to becoming a skilled
programmer.
Designing Flowcharts for Sorting Algorithms

Here's a general approach to designing a flowchart for a sorting algorithm:

1. Identify the Algorithm: Choose a sorting algorithm like Bubble Sort, Selection
Sort, Insertion Sort, Merge Sort, or Quick Sort.

2. Understand the Logic: Familiarize yourself with the algorithm's steps. How does
it compare elements? How does it swap elements (if applicable)? Does it use
loops or recursion?

3. Start with the Main Flow: Use the start symbol and initial process boxes to
represent the beginning and initialization steps (e.g., declaring variables, getting
input for the array of numbers to be sorted).

4. Looping for Iterations: Most sorting algorithms involve iterating through the data
multiple times. Use a loop symbol (rectangle with repetition lines) to represent the
main loop of the algorithm.

5. Decision Making: Within the loop, use decision diamonds to represent

comparisons between elements. Based on the comparison result (e.g., greater
than, less than), connect the flowchart with arrows to indicate the next steps (e.g.,
swapping elements, moving a pointer).

6. Swapping Elements (if applicable): For algorithms that swap elements to

achieve sorting, use process boxes to represent the swapping logic.

7. Updating Loop Variables: Inside the loop, include process boxes to update loop
variables (e.g., counters) to control the iteration.

8. End of Loop: Connect the loop back to the decision point or exit the loop entirely
when the sorting is complete.

9. Output: Use an output symbol to represent displaying the sorted array.

Tips:

 Keep your flowchart clear and concise, focusing on the essential steps.
 Use labels on the connectors to explain the flow of data based on decisions.
 Start with simpler sorting algorithms like Bubble Sort or Selection Sort before
moving to more complex ones like Merge Sort or Quick Sort.
Example: Flowchart for Bubble Sort :

Explanation:

1. The flowchart starts with the

initialization of variables (array
size, loop counters).

2. The outer loop iterates through

the array (n-1 times).

3. The inner loop compares

adjacent elements.

4. If elements are in the wrong order

(current element greater than the
next), a swapping process
occurs.

5. The loop continues, and these

comparisons and potential swaps
happen in each iteration,
gradually bubbling the largest
elements to the end.

6. After the outer loop completes,

the array is sorted.

7. Finally, the sorted array is

displayed.
Algorithmic Problem Solving

1. Problem Analysis for Algorithmic Solutions

Before diving into code, it's crucial to understand the problem we're trying to solve.
This involves:

 Identifying the Input: What data will the algorithm receive (e.g., numbers, text,
lists)?

 Defining the Output: What should the algorithm produce after processing the input
(e.g., sorted data, a specific value)?

 Understanding Constraints: Are there limitations on memory usage, processing

time, or specific operations that can be performed?

Example:

Problem: Find the largest number in a list of numbers.

Input: A list of numbers (e.g., [5, 2, 8, 1, 3])

Output: The largest number in the list (e.g., 8)

Constraints: None specified in this example.

2. Implementing Search Algorithms

Search algorithms are fundamental tools for finding specific data within collections.
Here, we'll explore two popular options:

A. Linear Search:

 Concept: This algorithm iterates through each element of a collection (like a list) and
compares it to the target value. If a match is found, the search ends and the index of the
element is returned.

 Efficiency: Linear Search is relatively simple to implement but can be slow for large
datasets because it needs to check every element.

B. Binary Search:

 Concept: This algorithm works only on sorted collections. It repeatedly divides the
search space in half by comparing the target value with the middle element. This process
eliminates half of the remaining elements in each iteration.

 Efficiency: Binary Search is significantly faster than Linear Search for sorted datasets
because it reduces the search space exponentially.
3. Writing and Visualizing Search Algorithms

Now that you understand the concepts, let's learn how to express them in code:

A. Using Pseudocode:

Pseudocode is a human-readable way to represent algorithms, using plain English

with some programming-like keywords. This allows you to focus on the logic before
translating it into actual code.

Example (Linear Search Pseudocode):

DECLARE list (array of numbers)

DECLARE target_value (number)

FOR i = 0 TO LENGTH(list) - 1
IF list[i] == target_value THEN
RETURN i ; Index of the target value found
END IF
END FOR

RETURN -1 ; Target value not found

B. Visualizing with Flowcharts:

Flowcharts use symbols to represent the flow of data and decision points within an
algorithm. They provide a visual aid to understand how the search progresses.

Example (Binary Search Flowchart):

Pseudocode for binary search:

FUNCTION binary_search(array, target)

# Initialize variables
low = 0 ; Index of the first element in the search range
high = length(array) - 1 ; Index of the last element in the
search range

# Loop until the target is found or the search range is exhausted

WHILE low <= high
# Find the middle element of the current search range
mid = (low + high) // 2 ; Integer division for floor operation

# Check if the target is at the middle element

IF array[mid] == target THEN
RETURN mid ; Target found, return its index
ELSEIF array[mid] < target THEN
# Search the right half of the array (target is greater)
low = mid + 1
ELSE
# Search the left half of the array (target is smaller)
high = mid - 1
END IF
END WHILE

# Target not found

RETURN -1 ; Indicate target not found (or any other appropriate
value)
END FUNCTION

Practice Makes Perfect:

 Implement these search algorithms in a programming language of your choice (e.g., C,

Python, Java).

 Test your code with various datasets and analyze its performance.
Advanced Algorithms and Efficiency:

Exploring Recursion with Fibonacci and Factorial

You've conquered the basics of algorithmic problem solving. Now, let's dive into
recursion, a powerful technique for solving problems that can be broken down into
smaller versions of themselves.

We'll explore how recursion can be both elegant and inefficient, using the Fibonacci
sequence and factorial calculation as examples.

Recursive Magic: Understanding the Concept

 Recursion occurs when a function calls itself within its own definition.

 It's a powerful approach for problems with a natural self-similar structure.

The Fibonacci Sequence

The Fibonacci sequence is a series of numbers where each number is the sum of
the two preceding numbers (starting from 0 and 1). Recursion perfectly fits
calculating Fibonacci numbers:

FUNCTION fibonacci(n) ; n is the position in the sequence (0-

indexed)
IF n <= 1 THEN
RETURN n ; Base case (0 or 1)
ELSE
RETURN fibonacci(n-1) + fibonacci(n-2) ; Recursive call to
calculate previous terms
END IF
END FUNCTION

This code works! However, it has a significant drawback: inefficiency for larger
values of n. Each function call calculates the same subproblems repeatedly (e.g.,
calculating fibonacci(2) happens multiple times for fibonacci(4)).

Time Complexity

The recursive Fibonacci sequence implementation has a time complexity of O(2^n),

which grows exponentially with n. This is because of the repeated calculations of
subproblems. Imagine calculating fibonacci(10) - an enormous number of redundant
function calls occur!
Factorial Calculation:

Factorial (denoted by n!) is the product of all positive integers less than or equal to n.
Recursion is another way to calculate factorials:

FUNCTION factorial(n)
IF n == 0 THEN
RETURN 1 ; Base case (factorial of 0 is 1)
ELSE
RETURN n * factorial(n-1) ; Recursive call to calculate
factorial of n-1
END IF
END FUNCTION

Similar to Fibonacci, this approach suffers from repeated calculations for

subproblems, leading to exponential time complexity (O(2^n)).

Alternative Approaches

While recursion offers a clear and concise approach, its repeated calculations can be
wasteful for larger inputs. Here are some alternative approaches for efficiency:

 Iterative Solutions: Often, problems solvable with recursion can be rewritten

using loops, avoiding redundant calculations. This can significantly improve
performance for larger inputs.

 Dynamic Programming (DP): DP is a technique that stores the results of

subproblems to avoid redundant calculations. We can use DP to optimize both
Fibonacci and factorial calculations.

Recursion can be a powerful tool, but it's crucial to consider its efficiency
implications, especially for larger datasets.

The journey to becoming a skilled algorithm designer involves understanding diverse

techniques and choosing the most appropriate one for the task at hand.
A. Optimized Fibonacci with DP:

FUNCTION fibonacci_dp(n, memo) ; n is the position, memo is a

dictionary to store results
IF n IN memo THEN
RETURN memo[n] ; Retrieve pre-calculated value if it exists
ELSE
IF n <= 1 THEN
result = n
ELSE
result = fibonacci_dp(n-1, memo) + fibonacci_dp(n-2, memo)
END IF
memo[n] = result ; Store the calculated value for future use
END IF
RETURN result
END FUNCTION

This approach uses a dictionary (memo) to store the calculated values of

subproblems.

When a subproblem is encountered again, its pre-calculated value is retrieved from

the dictionary, avoiding redundant calculations.

This significantly improves the time complexity from O(2^n) (recursive) to O(n) (DP)!

B. Optimized Factorial with DP:

FUNCTION factorial_dp(n, memo)

IF n IN memo THEN
RETURN memo[n] ; Retrieve pre-calculated value if it exists
ELSE
IF n == 0 THEN
result = 1
ELSE
result = n * factorial_dp(n-1, memo)
END IF
memo[n] = result ; Store the calculated value for future use
END IF
RETURN result
END FUNCTION

Here, the memo dictionary stores the calculated factorials.

When a factorial needs to be computed, the pre-calculated value is used if it exists,

drastically improving efficiency compared to the recursive approach (O(n) vs. O(n!)).
Iterative Fibonacci Sequence:

Here's an iterative approach (pseudocode) for calculating the nth Fibonacci number:

FUNCTION fibonacci_iterative(n)
a, b = 0, 1 ; Initialize variables to store previous two numbers
FOR i = 0 TO n-1 ; Iterate n times
c = a + b ; Calculate the current Fibonacci number
a = b ; Update a for the next iteration
b = c ; Update b for the next iteration
END FOR
RETURN c ; Return the nth Fibonacci number
END FUNCTION

Explanation:

 We initialize two variables, a and b, with the first two Fibonacci numbers (0 and 1).
 We iterate n times, calculating each Fibonacci number based on the previous two using
the formula c = a + b.
 In each iteration, we update a and b to hold the previous two numbers for the next
calculation.
 Finally, after n iterations, c holds the nth Fibonacci number, which is returned.

Time Complexity:

This iterative approach has a time complexity of O(n). This means the running time
grows linearly with the input size (n), significantly faster than the recursive approach
(O(2^n)). The loop iterates n times, performing constant-time operations in each
iteration.

Iterative Factorial Calculation:

Here's an iterative approach (pseudocode) for calculating the factorial of a number

(n!):

FUNCTION factorial_iterative(n)
result = 1 ; Initialize result to 1 (factorial of 0)
FOR i = 1 TO n ; Iterate from 1 to n
result = result * i ; Multiply the result by the cur Number (i)
END FOR
RETURN result ; Return the factorial of n
END FUNCTION

Explanation:

 We initialize the result variable to 1 (factorial of 0).

 We iterate from 1 to n, multiplying the current result with the value of i in each iteration.
 This process essentially multiplies all positive integers less than or equal to n.
 After the loop completes, result holds the factorial of n, which is returned.
 Time Complexity:

This iterative approach also has a time complexity of O(n). Similar to the iterative
Fibonacci approach, the loop iterates n times, performing constant-time operations in
each iteration.

3. Conclusion:

Both iterative solutions demonstrate significant improvements in efficiency compared

to the recursive approaches for Fibonacci and factorial calculations. They avoid
redundant calculations and have a linear time complexity, making them more
suitable for larger input values.

Choosing the Right Approach:

 Recursion: While recursion offers a concise approach, it can be inefficient for problems with
repeated subproblems. However, it might be preferable for specific problems where the
recursive solution is more readable or easier to understand.
 Iteration: When efficiency is a concern, iterative solutions are generally preferred, especially
for calculations like Fibonacci and factorial. They offer a clear structure and avoid redundant
calculations.
Understanding Big O Notation

When it comes to analyzing algorithms, one of the most fundamental concepts you'll encounter is
algorithm efficiency. This concept refers to how well an algorithm performs in terms of time and
space requirements as the size of the input data increases. Big O notation is a mathematical notation
used to describe the efficiency of algorithms in terms of their worst-case or asymptotic behavior.

What is Big O Notation?

Big O notation provides a way to express the upper bound of the time or space complexity of an
algorithm in relation to the size of its input. In simpler terms, it tells us how the runtime or memory
usage of an algorithm grows relative to the size of the input.

Key Points to Understand:

1. Worst-Case Analysis: Big O notation typically represents the worst-case scenario of an

algorithm. It helps in understanding how the algorithm will perform when given the largest
possible input.

2. Asymptotic Analysis: Big O notation focuses on the behavior of an algorithm as the size of
the input approaches infinity. It ignores constant factors and lower-order terms, focusing on
the dominant factor that influences the growth rate of the algorithm.

3. Simplification: Big O notation simplifies the analysis of algorithms by providing a high-level

view of their efficiency. It allows us to compare algorithms and understand their relative
performance without getting bogged down in the details of specific implementations or
hardware.

Common Notations:

1. O(1): Constant Time Complexity. The algorithm's runtime or space usage does not change
with the size of the input.

2. O(log n): Logarithmic Time Complexity. The algorithm's performance grows logarithmically
with the size of the input. Examples include binary search.

3. O(n): Linear Time Complexity. The algorithm's performance scales linearly with the size of
the input. Examples include simple array traversal.

4. O(n log n): Log-linear Time Complexity. Common in efficient sorting algorithms like merge
sort and quicksort.

5. O(n^2): Quadratic Time Complexity. The algorithm's performance grows quadratically with
the size of the input. Examples include nested loops.

6. O(2^n): Exponential Time Complexity. The algorithm's performance doubles with each
additional input. Typically seen in brute-force algorithms.

7. O(n!): Factorial Time Complexity. The algorithm's performance grows factorially with the
size of the input. Typically seen in brute-force permutation algorithms.
Understanding Big O notation is essential for analyzing and comparing the efficiency of
algorithms.

It provides a standardized way to express and reason about the performance characteristics
of algorithms, enabling developers and engineers to make informed decisions when
designing and selecting algorithms for various tasks.

By grasping this notation, you can better comprehend the trade-offs involved in algorithm
design and choose the most suitable approach for your specific requirements.

Calculating Big O notation

It involves analyzing the algorithm's behavior as the size of the input grows. Here's a step-by-step
explanation with an example:

Step 1: Identify the Dominant Operation

 Look for the part of the algorithm that contributes the most to its time complexity.

 Focus on the operations that are repeated or have the most significant impact on the
algorithm's runtime.

Step 2: Express Time Complexity in Terms of 'n'

 Represent the algorithm's time complexity as a function of the input size, typically denoted
as 'n'.

 Ignore constant factors, lower-order terms, and focus on the dominant factor.

Step 3: Analyze Loops, Recursion, and Nested Operations

 For loops, consider how many times the loop iterates based on the input size.

 For recursive algorithms, determine the number of recursive calls and their impact on the
overall runtime.

 For nested operations, multiply the complexities of each operation.

Step 4: Example Calculation

Let's calculate the time complexity of a simple algorithm that finds the maximum element in an
unsorted array.

Define find_max(arr):

max_element = arr[0]

for num in arr:

if num > max_element:

max_element = num

return max_element
Step-by-Step Analysis:

1. Dominant Operation: The loop iterates through each element of the array.

2. Express Time Complexity: The number of iterations depends on the size of the array 'n', so
the time complexity can be expressed as O(n).

3. Loop Analysis: The loop runs 'n' times, where 'n' is the size of the input array.

4. Final Time Complexity: O(n)

Conclusion:

 The time complexity of the 'find_max' algorithm is O(n), meaning it grows linearly with the
size of the input array.

 Regardless of the size of the array, the algorithm's runtime increases proportionally.

 This linear relationship between input size and runtime helps in understanding the
algorithm's scalability and performance characteristics.