University of Hafr AlBatin

COLLEGE OF COMPUTER SCIENCE &

ENGINEERING

PROJECT REPORT

( CSE 353 – DESIGN AND ANALYSIS OF ALGORITHMS )

Algorithms for Diverse Problem Solving

Master Theorem
Selection Problem
Majority Element
Min-Heap and Heap Sort

Submitted By:

1
 Table of Contents

Table of Contents............................................................................................................................1
1 Introduction.................................................................................................................................2
3. Background................................................................................................................................4
1 Master Theorem..........................................................................................................................4
2 Selection Problem........................................................................................................................4
3 Majority Element.........................................................................................................................4
4 Min-Heap/Heap Sort...................................................................................................................4
4.Requirements and Specifications.................................................................................................5
 4.1 Functional User Requirements......................................................................................5
 4.2 Non-Functional User Requirements..............................................................................6
5.System Design..............................................................................................................................7
5.1 Solution Concept......................................................................................................................7
1. Selection Problem..................................................................................................................7
2. Min-Heap/Sort.......................................................................................................................7
3. Master Theorem.....................................................................................................................8
4. Majority Element....................................................................................................................8
6.Testing, Analysis.........................................................................................................................12
1. Output of your code................................................................................................................12
1. Master Theorem...................................................................................................................12
2. Selection Problem................................................................................................................12
3. Majority Element..................................................................................................................13
8. References................................................................................................................................15
Appendix: Source Code.................................................................................................................16

2
 1 Introduction

Algorithms play a pivotal role in modern computing, serving as the foundation for

solving complex problems efficiently. By formalizing processes for data manipulation,

computation, and decision-making, algorithms are indispensable in software development

and engineering. This report focuses on implementing four essential algorithms—Master

Theorem, Selection Problem, Majority Element, and Min-Heap/Heap Sort—within a

modular and user-friendly Java application.

The significance of these algorithms lies in their practical applications:

 Master Theorem helps analyze recursive problems, crucial in algorithm design

and complexity analysis.

 Selection Problem addresses key data retrieval challenges, such as finding the

median or kth smallest element.

 Majority Element is used in decision-making systems where identifying a

dominant data item is critical.

 Min-Heap/Heap Sort aids in efficient sorting and priority-based tasks, such as

scheduling and resource allocation.

This project integrates these algorithms into a cohesive program, offering an interactive

experience to users while showcasing algorithmic principles.

3
2. Problem Statement

In computational environments, the efficiency of algorithm implementation is directly

linked to the effectiveness of software systems. Challenges arise in selecting appropriate

algorithms for specific tasks, optimizing their execution, and making their results

accessible through intuitive interfaces.

The project aims to address the following key challenges:

1. Developing a unified interface to explore various algorithms.

2. Implementing algorithms to handle diverse computational tasks.

3. Ensuring accuracy and efficiency in algorithm execution.

4. Presenting outputs in a clear, user-friendly manner.

2.1 Solution

The proposed solution is a menu-driven Java application that incorporates the four

selected algorithms. The program ensures modularity, robustness, and scalability while

providing clear guidance to the user. The system architecture includes:

1. Interactive Menu: Allows users to select and execute algorithms.

2. Modular Implementation: Each algorithm operates independently for simplicity

and maintainability.

3. Clear Outputs: Results are presented with detailed explanations for educational

and practical purposes.

This solution addresses the problem by combining theoretical concepts with hands-on

implementation, enabling users to understand and apply the algorithms effectively.

4
3. Background

Understanding the background and significance of each algorithm provides a solid

foundation for their implementation.

1 Master Theorem

The Master Theorem is a fundamental tool in analyzing the time complexity of divide-
and-conquer algorithms. By evaluating recurrence relations, it determines whether the
recursion dominates, the division dominates, or the two contribute equally. This analysis
is essential in computational theory and algorithm optimization.

2 Selection Problem

This problem involves identifying the kth smallest element or median in a dataset, which
is vital in statistical analysis, machine learning, and database management. Efficient
algorithms ensure quick access to critical data points, even in large datasets.

3 Majority Element

The Majority Element algorithm identifies the element that appears more than half the
time in a dataset, if such an element exists. This is critical in consensus systems, decision-
making algorithms, and voting mechanisms.

4 Min-Heap/Heap Sort

Min-Heaps provide a structure where the smallest element is always at the root, enabling
efficient priority-based operations. Heap Sort leverages this property for sorting datasets,
combining the benefits of sorting algorithms and heap operations.

These algorithms are not only theoretical but have real-world applications across
industries, from computer science to business analytics. This project demonstrates their
functionality, providing insights into their practical usage.

4. Requirements and Specifications

5
 4.1 Functional User Requirements

The system is designed to meet the following functional requirements, ensuring that the
implemented algorithms are accessible, efficient, and user-friendly.

 4.1.1 Master Theorem

 Input: The system should allow users to input three parameters:
o aaa: Number of subproblems in the recursion.
o bbb: Factor by which the problem size is divided in each recursive step.
o f(n)f(n)f(n): The function representing the non-recursive work (e.g.,
ndn^dnd).
 Process: The program must analyze the recurrence relation using the Master
Theorem, determining whether the recursion, division, or both dominate the
complexity.
 Output: The system should output the applicable case (Case 1, Case 2, or Case 3)
and the time complexity of the algorithm.
 4.1.2 Selection Problem

 Input:
o A dataset (nnn) provided by the user.
o The value of kkk, representing the kth smallest element to be located.
 Process: The program should sort the input dataset and identify the kth smallest
element based on the user’s input.
 Output: The system must display the kth smallest element along with the sorted
dataset for verification.

 4.1.3 Majority Element

 Input:
o A dataset (nnn) of integers provided by the user.
 Process: The system must implement the Boyer-Moore Voting Algorithm to
determine the majority element, if one exists.
o A majority element is defined as an element appearing more than
n/2n/2n/2 times in the dataset.
 Output:
o If a majority element exists, display the element.
o Otherwise, display “No majority element exists.”

 4.1.4 Min-Heap/Sort

 Input:
o A dataset (nnn) of integers provided by the user.
 Process:

1. Build a Min-Heap from the input dataset.

2. Perform Heap Sort to sort the dataset in ascending order.

6
  Output:
o Display the Min-Heap structure.
o Display the sorted array.

 4.2 Non-Functional User Requirements

To enhance the system’s usability and performance, the following non-functional

requirements must be fulfilled:

1. Efficiency:
o The program should execute each algorithm with minimal computational
overhead, ensuring swift performance even for large datasets.
2. Robustness:
o The system should handle invalid inputs gracefully by providing
appropriate error messages and guidance for valid inputs.
3. Scalability:
o The program must support datasets of varying sizes, accommodating both
small and large inputs without performance degradation.
4. User Experience:
o The interface should be intuitive and user-friendly, with clear instructions
and prompts.
o Outputs should be presented in a structured and visually appealing format.
5. Portability:
o The program should be platform-independent, ensuring compatibility
across major operating systems with a standard Java runtime environment.
6. Maintainability:
o The codebase should be modular, making it easy to update or expand the
system with additional algorithms or features in the future.
7. Accuracy:
o The algorithms must produce accurate and reliable results, conforming to
their theoretical principles.

5. System Design

5.1 Solution Concept

7
The solution concept revolves around a menu-driven application where users can select one of
the four implemented algorithms. Each algorithm operates as a distinct module, and the
program ensures seamless transitions between input, processing, and output stages.

The overall design incorporates the following key elements:

1. Interactive Menu: Acts as the entry point for user interaction, guiding users to the appropriate
algorithm module.
2. Algorithm Modules: Independent implementations of each algorithm to ensure modularity
and clarity.
3. Error Handling: Ensures robustness by managing invalid inputs gracefully.
4. Output Presentation: Outputs are formatted for readability and understanding, with
additional context where necessary.

1. Selection Problem
- Concept:
The Selection Problem module identifies the kth smallest element in a dataset. Sorting the
dataset simplifies this task, ensuring both correctness and clarity for users.

- Design Features:
1. Input Handling: Accepts a list of n numbers and the value of k from the user.
2. Processing: Implements a sorting algorithm (e.g., Quick Sort or Merge Sort) to arrange the
dataset in ascending order. The kth smallest element is then retrieved.
3. Output: Displays the sorted dataset and highlights the kth smallest element.

- Advantages:
1. Simplicity in logic.
2. Clarity of output for educational and verification purposes.

2. Min-Heap/Sort
- Concept:
The Min-Heap/Heap Sort module constructs a Min-Heap from the user’s input and uses it to sort
the dataset in ascending order.

- Design Features:
1. Heap Construction:
- Accepts a dataset of n integers from the user.
- Constructs a Min-Heap using a series of heapify operations.
2. Heap Sort:
- Iteratively extracts the minimum element from the heap and rebuilds it to maintain the heap
property.
3. Output:
- Displays the constructed Min-Heap as an array.
- Presents the sorted dataset in ascending order.

- Advantages:
1. Demonstrates the utility of heap structures for sorting.
2. Efficient time complexity for both heap construction and sorting (O(n log n)).

8
 3. Master Theorem
- Concept:
The Master Theorem module analyzes recurrence relations to determine the time complexity of
divide-and-conquer algorithms.

- Design Features:
1. Input Handling:
- Accepts three parameters from the user:
- a: Number of subproblems.
- b: Division factor.
- f(n): Function representing the non-recursive work.
2. Processing:
- Applies the Master Theorem formula:
- T(n) = aT(n/b) + f(n).
- Calculates the critical value p = log_b(a) and compares it to the degree d of f(n).
- Identifies the applicable case (Case 1, Case 2, or Case 3).
3. Output:
- Provides the time complexity of the recurrence along with an explanation of the applicable
case.

- Advantages:
1. Simplifies complex recurrence analysis.
2. Useful for students and developers analyzing divide-and-conquer algorithms.

4. Majority Element
- Concept:
The Majority Element module identifies an element that appears more than n/2 times in a
dataset, if such an element exists.

- Design Features:
1. Input Handling:
- Accepts a dataset of n integers from the user.
2. Processing:
- Implements the Boyer-Moore Voting Algorithm to identify a potential majority element.
- Validates the potential element by counting its occurrences.
3. Output:
- If a majority element exists, displays the element.
- Otherwise, outputs a message indicating that no majority element exists.

- Advantages:
1. Efficient time complexity (O(n)).
2. Compact logic with practical applications in decision-making systems.

9
Complete code :
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;

public class AlgorithmImplementation {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

while (true) {
System.out.println("\n========= Algorithm Implementation
=========");
System.out.println("1. Master Theorem");
System.out.println("2. Selection Problem (Median & Kth
Smallest)");
System.out.println("3. Finding the Majority Element");
System.out.println("4. Min-Heap and Heap Sort");
System.out.println("5. Exit");

System.out.println("============================================");
System.out.print("Enter your choice (1-5): ");

int choice = scanner.nextInt();

switch (choice) {
case 1 -> masterTheorem(scanner);
case 2 -> selectionProblem(scanner);
case 3 -> findMajorityElement(scanner);
case 4 -> minHeapAndHeapSort(scanner);
case 5 -> {
System.out.println("\nThank you for using the
program. Goodbye!");
scanner.close();
return;
}
default -> System.out.println("\nInvalid option. Please
try again.");
}
}
}

// Master Theorem
private static void masterTheorem(Scanner scanner) {
System.out.println("\n--- Master Theorem ---");
System.out.print("Enter the value of a: ");
int a = scanner.nextInt();
System.out.print("Enter the value of b: ");
int b = scanner.nextInt();
System.out.print("Enter f(n) as O(n^d). Enter d: ");
double d = scanner.nextDouble();

double logBaseBofA = Math.log(a) / Math.log(b);

10
 System.out.println("log_b(a): " + logBaseBofA);

if (logBaseBofA > d) {
System.out.println("Case 1: Complexity is O(n^" +
logBaseBofA + ")");
} else if (logBaseBofA == d) {
System.out.println("Case 2: Complexity is O(n^" + d + " *
log(n))");
} else {
System.out.println("Case 3: Complexity is O(n^" + d + ")");
}
}

// Selection Problem (Median & kth Smallest)

private static void selectionProblem(Scanner scanner) {
System.out.println("\n--- Selection Problem ---");
System.out.print("Enter the number of elements (n): ");
int n = scanner.nextInt();
int[] arr = new int[n];

System.out.println("Enter the elements:");

for (int i = 0; i < n; i++) {
arr[i] = scanner.nextInt();
}

System.out.print("Enter the value of k (1 to " + n + "): ");

int k = scanner.nextInt();

if (k < 1 || k > n) {
System.out.println("Invalid k value. It should be between 1
and " + n);
return;
}

Arrays.sort(arr);
System.out.println("Sorted Array: " + Arrays.toString(arr));
System.out.println("The " + k + "th smallest element is: " +
arr[k - 1]);
}

// Finding the Majority Element

private static void findMajorityElement(Scanner scanner) {
System.out.println("\n--- Finding the Majority Element ---");
System.out.print("Enter the number of elements (n): ");
int n = scanner.nextInt();
int[] arr = new int[n];

System.out.println("Enter the elements:");

for (int i = 0; i < n; i++) {
arr[i] = scanner.nextInt();
}

int count = 0, candidate = -1;

// Step 1: Find the candidate

11
 for (int num : arr) {
if (count == 0) {
candidate = num;
}
count += (num == candidate) ? 1 : -1;
}

// Step 2: Verify the candidate

count = 0;
for (int num : arr) {
if (num == candidate) count++;
}

if (count > n / 2) {
System.out.println("The majority element is: " +
candidate);
} else {
System.out.println("No majority element exists in the
array.");
}
}

// Min-Heap and Heap Sort

private static void minHeapAndHeapSort(Scanner scanner) {
System.out.println("\n--- Min-Heap and Heap Sort ---");
System.out.print("Enter the number of elements (n): ");
int n = scanner.nextInt();
int[] arr = new int[n];

System.out.println("Enter the elements:");

for (int i = 0; i < n; i++) {
arr[i] = scanner.nextInt();
}

PriorityQueue<Integer> minHeap = new PriorityQueue<>();

for (int num : arr) {
minHeap.add(num);
}

System.out.println("Min-Heap representation: " + minHeap);

int[] sortedArray = new int[n];

for (int i = 0; i < n; i++) {
sortedArray[i] = minHeap.poll();
}

System.out.println("Sorted array in ascending order: " +

Arrays.toString(sortedArray));
}
}

12
6. Testing, Analysis

1. Output of your code

1. Master Theorem

2. Selection Problem

13
 3. Majority Element

4. Min-Heap and Heap Sort

14
 7. Conclusion

The implementation of the four algorithms—Master Theorem, Selection Problem,

Majority Element, and Min-Heap/Sort—demonstrates the power of computational

algorithms in solving diverse problems efficiently. Through a modular design, this

project delivers an interactive, user-friendly system that not only fulfills functional

requirements but also adheres to key non-functional goals such as scalability, robustness,

and maintainability.

The Master Theorem provides a framework for analyzing the complexity of divide-and-

conquer algorithms, empowering users to evaluate algorithmic efficiency. The Selection

Problem offers a practical method for identifying the kth smallest element in a dataset,

with applications in statistical analysis and data processing. The Majority Element

algorithm effectively showcases its utility in decision-making systems by identifying

dominant elements in a dataset. Finally, the Min-Heap and Heap Sort implementation

emphasizes the importance of data structures in efficient sorting mechanisms,

highlighting their role in performance-critical applications.

15
8. References

[1]. Algorithms: Design Techniques and Analysis, M. Alsuwaiyel, World Scientific, 2016.

[2]. Introduction to Algorithms, by Leiserson, Stein, Rivest, Cormen, MIT Press.

[3]. T. H. Cormen, C. E. Leiserson, R. L. Rivest, and C. Stein, Introduction to

Algorithms, 3rd ed., MIT Press, 2009.

[4]. F. Chen, N. Chen, H. Mao, and H. Hu, "An efficient sorting algorithm-Ultimate
Heapsort (UHS)," arXiv preprint arXiv:1902.00257, 2019.

[5]. D. Cantone and G. Cincotti, "QuickHeapsort, an efficient mix of classical sorting

algorithms," Theoretical Computer Science, vol. 285, no. 1, pp. 25–42, 2002.

16