# Repository Overview

Welcome to this repository. This codebase appears to be a compact desktop application focused on demonstrating classic sorting algorithms through a simple Java Swing interface. It looks designed for hands-on exploration rather than as a large framework-based system, so the important pieces are the launcher window, the sorter window, and the algorithm helpers that perform the actual work. If you are new here, think of it as a small educational app with a GUI shell wrapped around several in-memory sorting implementations.

## Overview

This repository appears to implement a sorting visualizer or sorting demo application. The user flow is straightforward: pick a sorting algorithm from a menu, enter a list of integers, and view the sorted result in a second window. There is also an “Open Code” action that appears to open a text file for the selected algorithm, suggesting the app may be used alongside example source or notes.

The code is organized around a single package, `algo_Calc`, with the UI and sorting logic closely related. The project does not appear to rely on a web stack, service layer, or database; instead, it runs as a local desktop program and performs all sorting in memory.

## Technology Stack

The detected stack is lightweight and Java-based:

- **Java / Swing** — used for the desktop user interface
- **AWT event handling** — used for button actions and window lifecycle management
- **Standard Java collections and arrays** — used for parsing and sorting integer input
- **Process launching via `ProcessBuilder`** — appears to be used for the code-opening shortcut

No well-known external frameworks were detected from the imports. The repository appears to depend mainly on the Java standard library.

## Architecture

The architecture appears intentionally simple:

- `Frame` acts as the entry window and algorithm selector.
- `Sortingss` is the main interactive screen that receives input, dispatches sorting work, and displays output.
- `quiks`, `merg`, and `heaps` provide algorithm-specific implementations used by `Sortingss`.

```mermaid
flowchart LR
Frame["Frame"] --> Sortingss["Sortingss"]
Sortingss --> Quiks["quiks"]
Sortingss --> Merg["merg"]
Sortingss --> Heaps["heaps"]
```

In practice, the launcher hands control to the sorter window, and the sorter window chooses which algorithm helper to invoke based on the user’s selection.

## Module Guide

### `algo_Calc`

This appears to be the only top-level module in the repository, and it contains the application’s full UI and algorithm surface. `Frame` is the launcher class that presents the menu of sorting choices. `Sortingss` is the main window where users enter numbers and see results. The helper classes `quiks`, `merg`, and `heaps` implement quick sort, merge sort, and heap sort respectively, while the remaining sorting modes appear to be handled directly inside the sorter window.

The code reference catalog points to these main classes and helpers:

- `Frame` — the startup and navigation window
- `Sortingss` — the main sorting UI and dispatch logic
- `quiks` — quick sort helper
- `merg` — merge sort helper
- `heaps` — heap sort helper

## Getting Started

If you are new to the repository, the best reading order is:

1. **Start with `src/algo_Calc/Frame.java`** to understand how the application launches and how users choose an algorithm.
2. **Then read `src/algo_Calc/Sortingss.java`** to see the main input, dispatch, and output flow.
3. **Inspect the helper classes inside `Sortingss.java`** — `quiks`, `merg`, and `heaps` — to understand the sorting implementations themselves.

A few practical notes for first-time contributors:

- The application appears to be built as a Swing desktop UI, so the main entry points are the `main(...)` methods in `Frame` and `Sortingss`.
- The algorithm selection is driven by a numeric key passed from `Frame` into `Sortingss`.
- The input format appears to expect space-separated integers.
- The code is tightly coupled and UI-driven, so changes to behavior will likely involve both the launcher window and the sorter window.

If your goal is to extend the repository, a good next step would be to understand how `Sortingss.vis(...)` selects the active algorithm and how the submit handler parses and sorts the input array.