Skip to content

CS210 Project — Linked List Implementation & Runtime Analysis

Welcome to the documentation site for the CS210 Project, developed by
Shoug Alomran and Layan Bindayel
Under the supervision of Dr. Najla Althuniyan

This project evaluates how different sorting algorithms perform when applied to real-world student registration data stored in a custom Linked List structure.

Project Overview

  • Custom Data Structure

    Implementation of a fully functional Linked List to store and manage student registration records.

  • Demand Scoring

    A weighted demand scoring system that evaluates registration priority using multiple factors.

  • Sorting Algorithms

    Implementation and comparison of:

    • Selection Sort
    • Insertion Sort
    • Merge Sort
    • Quick Sort

  • Runtime Analysis

    Measurement and benchmarking of execution times to compare theoretical vs. practical performance.

Key Objectives

  • Build a fully functional program that reads, processes, and sorts real registration data.

  • Compare theoretical complexity (Big-O) with measured runtime performance.

  • Analyze how algorithm design impacts scalability.

  • Present clear, structured documentation for both implementation and analysis.

Project Structure

  • Introduction
    Background, problem statement, and scope.

  • System Design Overview
    Major components and execution flow.

  • Asymptotic Analysis
    Theoretical T(n) and O(n) complexity comparison.

  • Runtime Measurement
    Empirical performance evaluation.

  • Teamwork
    Task distribution and coordination.

  • Conclusion
    Findings and future recommendations.

  • References
    Academic and technical sources.

  • Appendices
    Flowcharts, screenshots, and source code.

Technologies Used

  • Language: Java
  • Environment: Visual Studio Code
  • Documentation: MkDocs Material
  • Version Control: GitHub

Repository

You can view the complete project source code and documentation:

CS210 Project Repository

Summary

This project integrates theoretical foundations with practical implementation. It demonstrates how runtime analysis reflects algorithmic efficiency and highlights the relationship between Linked Lists, sorting algorithms, and performance optimization in computational problem-solving.