SOFTWARE
DEVELOPMENT AND
ALGORITHMS
Presentation By
Group 7
LIST OF
CONTENTS
Software development life cycle
Introduction to algorithms and data
structures
-
problem solving and computational thinking
SOFTWARE DEVELOPMENT
is the process of creating, designing, deploying, and
supporting software applications. It involves a range of
activities that include writing code, debugging, testing,
and maintaining software to meet specific requirements.
The Software Development Life Cycle (SDLC) is a
structured process used for developing software
applications. It outlines various stages that software
projects go through, ensuring systematic planning,
execution, and delivery .
STAGES
OF
SDLC
Planning: Defining the project’s goals, scope, and resources.
•Requirements Gathering: Understanding what the users or
clients need the software to do.
•Design: Creating a blueprint or architecture for how the software
will work.
•Development: Writing the actual code to build the software.
•Testing: Checking the software for bugs and ensuring it works as
intended.
•Deployment: Releasing the software to users.
•Maintenance: Updating and fixing the software over time as
needed.
WHY IS IT IMPORTANT?
•Organized Process: SDLC breaks down software
development into clear steps, making it easier to
plan, manage, and track progress.
•Reduces Errors: By following a step-by-step
approach (like planning, design, coding, testing),
SDLC helps catch problems early, reducing bugs
and costly mistakes.
•Improves Quality: With proper testing and review
stages, SDLC ensures the final software meets
requirements and works well.
•Cost-Effective: Detecting and fixing issues early saves
money compared to fixing them later in the process.
•
ALGORITHMS
An algorithm is a finite sequence of well-defined
instructions to solve a problem or perform a task.
•Sorting Algorithms-Arrange a list of items in a specific order, like
alphabetically or by size.
Search Algorithms-Help you find a specific item in a list.
It simply goes through each element in the list one by one until it
finds the target or reaches the end of the list.
•Greedy Algorithms-These algorithms make the locally
optimal choice at each stage, hoping to find the global
optimum.
Add the numbers to reach 36
use the following numbers to add up
( 50, 40, 20,10,5,1)
• NORMAL
Greedy algorithm
10 5
10 5 20
10 5 10
5 5
1 5
5
= 5 1
36 5 =
1 36
=
36
DATA STRUCTURE
A data structure is a way to organize and
store data in a computer so that it can be used
efficiently. Different data structures are better
for different tasks.
EXAMPLE
•An array is a collection of items stored at contiguous
memory locations, allowing you to store multiple
values of the same type under a single variable name.
PROBLEM SOLVING
•is the process of identifying, analyzing, and
finding solutions to challenges or issues.
Computational Thinking
Computational Thinking
•A problem-solving process that involves various
thought processes such as logical analysis, pattern
recognition, abstraction, and algorithmic thinking.
Decomposition: Breaking down a problem into smaller
tasks.
oPattern recognition: Identifying patterns or
similarities in problems.
oAbstraction: Focusing on the important information
only.
oAlgorithm design: Creating a step-by-step solution.
Software development often requires problem-solving
skills to create effective programs.
Algorithms provide the tools to approach problems
efficiently within software.
Computational thinking is the thought process that enables
developers to break down complex problems and create
algorithmic solutions
.
LAMATS
Bubble Sort - *Imagine you have a row of books and want to sort them by height.* In Bubble
Sort, you look at each pair of books and swap them if the taller one is on the left. You keep doing
this, moving through the row again and again until there are no more swaps. Eventually, all the
books end up in order from shortest to tallest. –
*Key Idea*: Go through and swap until nothing is out of place.
Merge Sort - *Think of tearing a list in half, over and over, until each piece has just one item.*
Then, you start merging pairs back together, but you place them in order as you merge. By the
end, you’ll have a fully sorted list. –
*Key Idea*: Break down the list, then merge pieces in sorted order.
Insertion Sort - *Picture adding new items to a sorted pile.* With each new item, you place it
exactly where it should go among the sorted items. So, if you have a deck of cards and you’re
arranging them in order, you place each new card in the right position relative to the others.
- *Key Idea*: Place each new item where it belongs.
Binary Search - *Imagine a phone book sorted by last names, and you’re looking for a specific
name.* Instead of starting at the beginning, you flip to the middle. If the name you want is earlier
alphabetically, you know to search the first half. If it's later, you search the second half. You keep
splitting like this until you find the name.
- *Key Idea*: Quickly narrow down by halving the list each time. Each of these methods is a
different way of organizing or searching through a list, and they work best in different situations.
Breadth-First Search (BFS) - *Think of BFS like exploring in layers.* Imagine you’re
trying to find something in a maze. Instead of going down one path, you explore all
paths that are just one step away. Then, if you haven’t found it yet, you go two steps
away, then three, and so on. –
*How it works*: BFS uses a list (queue) to keep track of where to go next. You start
from the first place, look at all places nearby, and keep going level by level. –
*Use BFS* if you want to find the shortest route or path in a simple, unweighted
setup (like a maze or city map where each step is equal).
Depth-First Search (DFS) - *Think of DFS like going deep down one path before
trying another.* If you’re exploring a cave, DFS is like following one tunnel all the way
to the end. When you reach a dead end, you backtrack and try another tunnel. –
*How it works*: DFS uses a different list (stack) to keep track of where you are. You
go down a path as far as possible. If it’s not the right path, you backtrack and try the
next one. –
*Use DFS* when you want to explore every possible option, like checking every room
in a building to see what’s inside. ### Key Difference - BFS spreads out evenly (like
ripples in water). - DFS dives deep into one path at a time. Let me know if you'd like
examples or hints for implementing these
