This repository contains my laboratory activities, programming exercises, datasets, outputs, and final portfolio for the Design and Analysis of Algorithms (DAA) course.
The project includes Python implementations of searching algorithms, sorting algorithms, filtering programs, the N-Queens problem, and the Ford-Fulkerson algorithm.
This repository serves as a collection of my work in Design and Analysis of Algorithms.
It demonstrates the application of algorithmic concepts through Python programs, CSV datasets, generated outputs, and visualizations.
- Binary Search
- Linear Search
- Comb Sort
- Counting Algorithms
- Even Number Filtering
- N-Queens Problem
- Ford-Fulkerson Algorithm
- Dataset Processing
- Workload Balancing
- Algorithm Visualization
- Python
- CSV
- Matplotlib
- Visual Studio Code
- Git
- GitHub
Design-Analysis-and-Algorithm-Technologies/
├── BinarySearch.py
├── Comb_Sort_Algorithm.py
├── Counting_Algo.py
├── Even_Number_Filter.py
├── Final Project Portfolio/
├── LabAct3.py
├── LinearSearch.py
├── MidtermActivity-Good.py
├── Students_Grading_Dataset.csv
├── assignment_distribution.csv
├── chess-excel.png
├── machine_problems_dataset.csv
├── workload_balancing.png
└── README.md
Contains a simple implementation of the binary search algorithm.
Binary search works by repeatedly dividing a sorted list into smaller sections until the target value is found.
Contains a basic implementation of the linear search algorithm.
Linear search checks each element one by one until the target value is found or the list ends.
Contains an implementation of the Comb Sort algorithm.
Comb Sort improves on Bubble Sort by comparing elements that are farther apart and gradually reducing the gap between them.
Contains a simple counting algorithm implementation developed as part of the course activities.
Contains a Python program that reads data from a CSV file and filters even numbers.
The program uses:
machine_problems_dataset.csv
as its input dataset.
Contains a Python implementation of the N-Queens problem.
The N-Queens problem aims to place queens on a chessboard so that no two queens attack each other.
Shows the movement or final placement generated for the N-Queens activity.
Contains an implementation of the Ford-Fulkerson algorithm with visualization.
The Ford-Fulkerson algorithm is used to determine the maximum possible flow in a network.
Contains the dataset used in the Ford-Fulkerson or workload-distribution activity.
Contains the generated assignment or workload-distribution output from the Ford-Fulkerson program.
Contains the visualization produced by the Ford-Fulkerson workload-balancing activity.
Contains the files used in creating the final DAA portfolio.
Binary search is an efficient searching algorithm that works on sorted data.
Its time complexity is:
O(log n)
Linear search examines elements one at a time.
Its time complexity is:
O(n)
Comb Sort compares elements using a gap that gradually decreases until it reaches one.
Its average performance is generally better than Bubble Sort for unsorted lists.
The N-Queens problem is a backtracking problem where queens must be placed on a chessboard without attacking one another.
The solution ensures that no two queens share:
- The same row
- The same column
- The same diagonal
The Ford-Fulkerson algorithm computes the maximum flow in a flow network.
In this repository, it is applied to assignment distribution or workload balancing using student grading data.
git clone https://github.com/your-username/your-repository-name.gitReplace your-username and your-repository-name with your actual GitHub details.
cd your-repository-namepython --versionSome programs may require additional libraries such as Pandas and Matplotlib.
pip install pandas matplotlibUse the following format:
python filename.pyExamples:
python BinarySearch.pypython LinearSearch.pypython Comb_Sort_Algorithm.pypython Even_Number_Filter.pypython LabAct3.pypython MidtermActivity-Good.pyMake sure the required CSV files are stored in the same project folder as the Python programs that use them.
Required datasets include:
Students_Grading_Dataset.csv
machine_problems_dataset.csv
The exact file paths inside the programs must match the actual locations of the CSV files.
Depending on the program being executed, the output may include:
- Search results
- Sorted values
- Filtered even numbers
- N-Queens board placement
- Assignment distribution
- Maximum-flow results
- CSV output files
- Workload-balancing visualizations
Through this repository, I practiced:
- Implementing searching algorithms
- Implementing sorting algorithms
- Working with CSV datasets
- Applying backtracking
- Solving the N-Queens problem
- Understanding maximum-flow networks
- Applying the Ford-Fulkerson algorithm
- Generating algorithm visualizations
- Comparing algorithm behavior
- Organizing academic projects using GitHub
Possible improvements include:
- Adding sample input and output for each program
- Adding time and space complexity analysis
- Organizing files into separate folders
- Adding comments and documentation to each script
- Adding automated tests
- Improving error handling
- Adding interactive visualizations
- Comparing additional sorting algorithms
- Adding breadth-first and depth-first search
- Creating a single web-based algorithm portfolio
Lerrica Jeremy S. Torreno
This repository was created for academic and educational purposes as part of the Design and Analysis of Algorithms course.
The programs, datasets, and visualizations in this repository are intended for learning, laboratory activities, and academic demonstration.