Upload 12 files

.gitattributes

@@ -0,0 +1,2 @@
+demo1.gif filter=lfs diff=lfs merge=lfs -text
+demo2.gif filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 8501
+
+CMD ["streamlit","run","app.py","--server.port=8501","--server.address=0.0.0.0"]

README.md

@@ -1,28 +1,48 @@
----
-title: Sorting Algorithm Visualizer
-emoji: 📊
-colorFrom: blue
-colorTo: purple
-sdk: streamlit
-sdk_version: "1.32.2"
-app_file: app.py
-pinned: false
----
+# Sorting Algorithm Visualizer & Analyzer
 
-# Sorting Algorithm Visualizer
-
-A Streamlit-based web app that visually compares **Insertion Sort** and **Merge Sort** step-by-step using animated bar charts.
+An interactive Streamlit application to **visualize, analyze, and compare sorting algorithms**.  
+The project is inspired by *Introduction to Algorithms (CLRS)* and extended with modern visualization and benchmarking features.
 
 ## Features
+- Step-by-step visualization with bubble chart animations.
+- Supported algorithms: Insertion Sort, Merge Sort, Quick Sort, Heap Sort, Counting Sort, Radix Sort (LSD), Shell Sort, Bucket Sort
+- Metrics tracking:
+  - Execution time (ms)
+  - Comparisons
+  - Moves (writes/swaps)
+  - Number of frames
+  - Sorted OK check
+- Scaling benchmark: analyze performance as input size increases.
+- Export results as CSV.
+
 
-- Generates a random array for sorting
-- Side-by-side animated visualization of Insertion Sort and Merge Sort
-- Highlights active elements and sorted regions
-- Displays total number of sorting steps
-- Brief algorithm summaries
+![Demo GIF 1](demo1.gif)
+![Demo GIF 2](demo2.gif)
 
-## How to Run Locally
 
+## Installation
 ```bash
+git clone https://github.com/your-username/sorting-algorithm-visualizer.git
+cd sorting-algorithm-visualizer
 pip install -r requirements.txt
-streamlit run app.py
+```
+
+## Usage
+Run the Streamlit app:
+```bash
+streamlit run app.py
+```
+Open the app in your browser at `http://localhost:8501`.
+
+## Run with Docker
+Build the image:
+```bash
+docker build -t sorting-algorithm-visualizer .
+```
+
+Run the container:
+```bash
+docker run -p 8501:8501 sorting-algorithm-visualizer
+```
+
+Open the app in your browser at `http://localhost:8501`.

algorithms.py

@@ -1,63 +1,420 @@
-def insertion_sort(arr):
-    steps = []  # keep all steps here
-    a = arr.copy()
+# algorithms.py with metrics
+import math
+import time
+
+
+def _snap(steps, record_steps, a, active_i, boundary=-1):
+    if record_steps:
+        steps.append(
+            {"array": a.copy(), "active_index": active_i, "sorted_boundary": boundary}
+        )
+
 
+def insertion_sort(arr, record_steps: bool = True):
+    a = arr.copy()
+    steps = []
+    comparisons = 0
+    moves = 0
+    start = time.perf_counter()
     for i in range(1, len(a)):
         key = a[i]
         j = i - 1
-
-        while j >= 0 and a[j] > key:
-            a[j + 1] = a[j]
-            steps.append(
-                {"array": a.copy(), "active_index": j + 1, "sorted_boundary": i}
-            )
-            j -= 1
+        # at least one comparison if entering the while loop
+        while j >= 0:
+            comparisons += 1
+            if a[j] > key:
+                a[j + 1] = a[j]
+                moves += 1
+                _snap(steps, record_steps, a, j + 1, i)
+                j -= 1
+            else:
+                break
         a[j + 1] = key
-        steps.append(
-            {"array": a.copy(), "active_index": j + 1, "sorted_boundary": i}
-        )  # save every moment
-    return steps
+        moves += 1
+        _snap(steps, record_steps, a, j + 1, i)
+    end = time.perf_counter()
+    metrics = {"comparisons": comparisons, "moves": moves, "seconds": end - start}
+    return steps, metrics
 
 
-def merge_sort(arr):
-    steps = []
+def merge_sort(arr, record_steps: bool = True):
     a = arr.copy()
-    merge_sort_recursive(a, 0, len(a) - 1, steps)
-    return steps
+    steps = []
+    comparisons = 0
+    moves = 0
+    start = time.perf_counter()
 
-def merge_sort_recursive(arr,left,right,steps):
-    if left < right:
-        mid = (left + right) // 2
-        merge_sort_recursive(arr, left, mid, steps)
-        merge_sort_recursive(arr, mid + 1, right, steps)
-        merge(arr, left, mid, right, steps)
-
-def merge(arr, left, mid, right, steps):
-    left_part = arr[left:mid+1]
-    right_part = arr[mid + 1:right+1]
-    
-    i = j = 0
-    k = left
-
-    while i < len(left_part) and j < len(right_part):
-        if left_part[i] <= right_part[j]:
-            arr[k] = left_part[i]
-            steps.append({"array": arr.copy(), "active_index":k, "sorted_boundary": right})
+    def merge(left, mid, right):
+        nonlocal comparisons, moves
+        # Create copies of subarrays
+        left_part = a[left : mid + 1]
+        right_part = a[mid + 1 : right + 1]
+        i = j = 0
+        k = left
+
+        # Merge while both parts have elements
+        while i < len(left_part) and j < len(right_part):
+            comparisons += 1  # one comparison each loop
+            if left_part[i] <= right_part[j]:
+                a[k] = left_part[i]
+                moves += 1
+                _snap(steps, record_steps, a, k, right)
+                i += 1
+            else:
+                a[k] = right_part[j]
+                moves += 1
+                _snap(steps, record_steps, a, k, right)
+                j += 1
+            k += 1
+
+        # Copy remaining elements of left_part
+        while i < len(left_part):
+            a[k] = left_part[i]
+            moves += 1
+            _snap(steps, record_steps, a, k, right)
             i += 1
-        else:
-            arr[k] = right_part[j]
-            steps.append({"array": arr.copy(), "active_index":k, "sorted_boundary": right})
+            k += 1
+
+        # Copy remaining elements of right_part
+        while j < len(right_part):
+            a[k] = right_part[j]
+            moves += 1
+            _snap(steps, record_steps, a, k, right)
             j += 1
-        k += 1
-    
-    while i < len(left_part):
-        arr[k] = left_part[i]
-        steps.append({"array": arr.copy(), "active_index":k, "sorted_boundary": right})
-        i += 1
-        k += 1
-    
-    while j < len(right_part):
-        arr[k] = right_part[j]
-        steps.append({"array": arr.copy(), "active_index":k, "sorted_boundary": right})
-        j += 1
-        k += 1
+            k += 1
+
+    def sort(left, right):
+        if left >= right:
+            return
+        mid = (left + right) // 2
+        sort(left, mid)
+        sort(mid + 1, right)
+        merge(left, mid, right)
+
+    if len(a) > 0:
+        sort(0, len(a) - 1)
+
+    end = time.perf_counter()
+    metrics = {"comparisons": comparisons, "moves": moves, "seconds": end - start}
+    return steps, metrics
+
+
+def quick_sort(arr, record_steps: bool = True):
+    a = arr.copy()
+    steps = []
+    comparisons = 0
+    moves = 0
+
+    def swap(i, j, *, active_i=None, sorted_b=None):
+        nonlocal moves
+        if i == j:
+            return
+        (
+            a[i],
+            a[j],
+        ) = (
+            a[j],
+            a[i],
+        )
+        moves += 2
+        _snap(
+            steps,
+            record_steps,
+            a,
+            i if active_i is None else active_i,
+            -1 if sorted_b is None else sorted_b,
+        )
+
+    def partition(low, high):
+        nonlocal comparisons, moves
+        pivot = a[high]
+        i = low - 1
+        # compare high-1 and pivot
+        for j in range(low, high):
+            comparisons += 1
+            if a[j] <= pivot:
+                i += 1
+                swap(i, j, active_i=j)
+        # put pivot back to place
+        swap(i + 1, high, active_i=i + 1, sorted_b=i + 1)
+        return i + 1
+
+    def qs(low, high):
+        if low < high:
+            p = partition(low, high)
+            qs(low, p - 1)
+            qs(p + 1, high)
+
+    start = time.perf_counter()
+    if a:
+        qs(0, len(a) - 1)
+    seconds = time.perf_counter() - start
+
+    metrics = {"comparisons": comparisons, "moves": moves, "seconds": seconds}
+    return steps, metrics
+
+
+def counting_sort(arr, k=None, record_steps: bool = True):
+    a = arr.copy()
+    steps = []
+    comparisons = 0
+    moves = 0
+    if not a:
+        return steps, {"comparisons": 0, "moves": 0, "seconds": 0.0}
+
+    # negatifleri desteklemiyorsak koruma (istersen offset ile destekleyebilirsin)
+    if min(a) < 0:
+        raise ValueError("Counting Sort: negatif değerler desteklenmiyor.")
+
+    # k (değer aralığı) verilmediyse max+1 al
+    if k is None:
+        k = max(a) + 1
+
+    start = time.perf_counter()
+
+    count = [0] * k
+    for v in a:
+        count[v] += 1
+    for i in range(1, k):
+        count[i] += count[i - 1]
+
+    out = [0] * len(a)
+    for v in reversed(a):
+        count[v] -= 1
+        out[count[v]] = v
+
+    for i, v in enumerate(out):
+        a[i] = v
+        moves += 1
+        _snap(steps, record_steps, a, i, i)
+
+    seconds = time.perf_counter() - start
+    return steps, {"comparisons": comparisons, "moves": moves, "seconds": seconds}
+
+
+def radix_sort_lsd(arr, base=10, record_steps: bool = True):
+    a = arr.copy()
+    steps = []
+    comparisons = 0
+    moves = 0
+
+    if not a:
+        return steps, {"comparisons": 0, "moves": 0, "seconds": 0.0}
+    if base < 2:
+        raise ValueError("radix base must be >= 2")
+
+    start = time.perf_counter()
+
+    def digit(x, exp):
+        return (x // exp) % base
+
+    exp = 1
+    maxv = max(a)
+
+    # for each digit place
+    while maxv // exp > 0:
+        # stable counting sort by current digit
+        count = [0] * base
+
+        # count
+        for v in a:
+            d = digit(v, exp)
+            count[d] += 1
+
+        # prefix sums
+        for i in range(1, base):
+            count[i] += count[i - 1]
+
+        # build output(scan from right)
+        out = [0] * len(a)
+        for i in range(len(a) - 1, -1, -1):
+            v = a[i]
+            d = digit(v, exp)
+            count[d] -= 1
+            out[count[d]] = v
+
+        for i, v in enumerate(out):
+            a[i] = v
+            moves += 1
+            _snap(steps, record_steps, a, i, i)
+        exp *= base
+
+    seconds = time.perf_counter() - start
+    metrics = {"comparisons": comparisons, "moves": moves, "seconds": seconds}
+    return steps, metrics
+
+
+# --- Heap Sort (max-heap, in-place) with metrics & step recording ---
+# steps: her adımda {"array": a.copy(), "active_index": i, "sorted_boundary": b}
+# - active_index: o karede yeni yazılan / swap’e giren indeks
+# - sorted_boundary: heapsort’ta sıralı kuyruk (suffix) başlangıcı; j >= boundary -> "sorted"
+# metrics:
+# - comparisons: her a[l] > a[m] veya a[r] > a[m] kontrolü 1 karşılaştırma
+# - moves: diziye her yazma 1; swap 2 move
+def heap_sort(arr, record_steps: bool = True):
+    a = arr.copy()
+    steps = []
+    comparisons = 0
+    moves = 0
+
+    heap_sorted = -1
+
+    def snapshot(active_i, boundary):
+        _snap(steps, record_steps, a, active_i, boundary)
+
+    def swap(i, j):
+        nonlocal moves
+        if i == j:
+            return
+        a[i], a[j] = a[j], a[i]
+        moves += 2
+        snapshot(i, heap_sorted)
+
+    def heapify(n, i):
+        nonlocal comparisons
+        while True:
+            largest = i
+            l = 2 * i + 1
+            r = 2 * i + 2
+
+            if l < n:
+                comparisons += 1
+                if a[l] > a[largest]:
+                    largest = l
+            if r < n:
+                comparisons += 1
+                if a[r] > a[largest]:
+                    largest = r
+            if largest == i:
+                break
+
+            swap(i, largest)
+            i = largest
+
+    start = time.perf_counter()
+
+    n = len(a)
+    if n <= 1:
+        metrics = {"comparisons": 0, "moves": 0, "seconds": 0.0}
+        return steps, metrics
+
+    # build max heap
+    for i in range(n // 2 - 1, -1, -1):
+        heapify(n, i)
+    # extract max
+    for end in range(n - 1, 0, -1):
+        swap(0, end)
+        heap_sorted = end
+        heapify(end, 0)
+
+    seconds = time.perf_counter() - start
+    metrics = {"comparisons": comparisons, "moves": moves, "seconds": seconds}
+    return steps, metrics
+
+
+def shell_sort(arr, record_steps: bool = True):
+    a = arr.copy()
+    steps = []
+    comparisons = 0
+    moves = 0
+
+    def snap(active_i, boundary=-1):
+        _snap(steps, record_steps, a, active_i, boundary)
+
+    start = time.perf_counter()
+
+    n = len(a)
+    if n <= 1:
+        return steps, {"comparisons": 0, "moves": 0, "seconds": 0.0}
+
+    gap = n // 2
+    while gap > 0:
+        for i in range(gap, n):
+            key = a[i]
+            j = i - gap
+
+            while j >= 0:
+                comparisons += 1
+                if a[j] > key:
+                    a[j + gap] = a[j]
+                    moves += 1
+                    snap(j + gap)
+                    j -= gap
+                else:
+                    break
+            a[j + gap] = key
+            moves += 1
+            snap(j + gap)
+
+        gap //= 2
+
+    seconds = time.perf_counter() - start
+    metrics = {"comparisons": comparisons, "moves": moves, "seconds": seconds}
+    return steps, metrics
+
+
+def bucket_sort(arr, num_buckets=None, record_steps: bool = True):
+    a = arr.copy()
+    steps = []
+    comparisons = 0
+    moves = 0
+
+    if not a:
+        return steps, {"comparisons": 0, "moves": 0, "seconds": 0.0}
+
+    n = len(a)
+
+    if num_buckets is None:
+        num_buckets = max(1, int(math.sqrt(n)))
+
+    start = time.perf_counter()
+
+    maxv = max(a)
+
+    # normlize values range between 0 and 1
+    if maxv == 0:
+        seconds = time.perf_counter() - start
+
+        for i, v in enumerate(a):
+            _snap(steps, record_steps, a, i, i)
+        return steps, {"comparisons": 0, "moves": 0, "seconds": seconds}
+
+    normalized = [x / (maxv + 1.0) for x in a]
+
+    # create buckets
+    buckets = [[] for _ in range(num_buckets)]
+
+    # split values to buckets
+    for v_norm, v_orig in zip(normalized, a):
+        idx = int(v_norm * num_buckets)
+        if idx >= num_buckets:
+            idx = num_buckets - 1
+        buckets[idx].append(v_orig)
+
+    # sort buckets
+
+    for b in buckets:
+        for i in range(1, len(b)):
+            key = b[i]
+            j = i - 1
+            while j >= 0:
+                comparisons += 1
+                if b[j] > key:
+                    b[j + 1] = b[j]
+                    j -= 1
+                else:
+                    break
+            b[j + 1] = key
+
+    # save at main
+    write_i = 0
+    for b in buckets:
+        for v in b:
+            a[write_i] = v
+            moves += 1
+            _snap(steps, record_steps, a, write_i, write_i)
+            write_i += 1
+
+    seconds = time.perf_counter() - start
+    metrics = {"comparisons": comparisons, "moves": moves, "seconds": seconds}
+    return steps, metrics

app.py

@@ -1,39 +1,222 @@
 import random
-import plotly.graph_objects as go
+import statistics
+import time
+
 import matplotlib.pyplot as plt
+import pandas as pd
+import plotly.graph_objects as go
 import streamlit as st
-import time
 
-from algorithms import insertion_sort, merge_sort
+import algorithms as alg
+
+st.title("Sorting Algorithm Visualizer")
+
+
+def render_metrics(m):
+    if not m:
+        return
+    ms = m.get("seconds", 0.0) * 1000.0
+    comps = m.get("comparisons", 0)
+    moves = m.get("moves", 0)
+    c1, c2, c3 = st.columns(3)
+    with c1:
+        st.metric("Time (ms)", f"{ms:.2f}")
+    with c2:
+        st.metric("Comparisons", f"{comps:,}")
+    with c3:
+        st.metric("Moves", f"{moves:,}")
 
-st.title("Insertion Sort vs Merge Sort Visualizer")
 
-# --- Veri Girişi ---
 st.subheader("Input Configuration")
 length = st.slider("List length", 5, 20, 8)
-data = random.sample(range(1, 30), length)
+# Input type selector
+input_type = st.selectbox(
+    "Input type", ["Random", "Sorted", "Reversed", "Few unique"], index=0
+)
+# Generate data based on input type
+if input_type == "Random":
+    data = random.sample(range(1, 30), length)  # unique values
+elif input_type == "Sorted":
+    data = sorted(random.sample(range(1, 30), length))
+elif input_type == "Reversed":
+    data = sorted(random.sample(range(1, 30), length), reverse=True)
+else:  # Few unique
+    pool = random.sample(range(1, 30), k=min(3, max(1, length // 3)))
+    data = [random.choice(pool) for _ in range(length)]
+    random.shuffle(data)
+
 st.write(f"Input array: {data}")
 
-if st.button("Compare Insertion Sort vs Merge Sort"):
-    data_insertion = data.copy()
-    data_merge = data.copy()
+st.subheader("Scaling Benchmark (n -> time)")
+sizes_str = st.text_input("Sizes", value="10, 20, 40, 80, 160")
+try:
+    sizes = [int(x.strip()) for x in sizes_str.split(",") if x.strip()]
+    sizes = [s for s in sizes if s > 0]
+except Exception:
+    sizes = []
+
+runs_scale = st.slider("Runs per size", 3, 50, 10, step=1)
+
+algo_options = [
+    "Insertion Sort",
+    "Merge Sort",
+    "Quick Sort",
+    "Counting Sort",
+    "Radix Sort (LSD)",
+    "Heap Sort",
+    "Shell Sort",
+    "Bucket Sort",
+]
+selected_algos = st.multiselect(
+    "Algorithms to include",
+    options=algo_options,
+    default=[
+        "Insertion Sort",
+        "Merge Sort",
+        "Quick Sort",
+        "Counting Sort",
+        "Radix Sort (LSD)",
+        "Heap Sort",
+        "Shell Sort",
+        "Bucket Sort",
+    ],
+)
+
+
+def make_data(n: int, input_type: str):
+    if input_type == "Random":
+        return [random.randint(1, max(30, n * 3)) for _ in range(n)]
+    elif input_type == "Sorted":
+        arr = [random.randint(1, max(30, n * 3)) for _ in range(n)]
+        return sorted(arr)
+    elif input_type == "Reversed":
+        arr = [random.randint(1, max(30, n * 3)) for _ in range(n)]
+        return sorted(arr, reverse=True)
+    else:
+        pool_size = max(2, min(10, n // 5))
+        pool = [random.randint(1, max(30, n * 3)) for _ in range(pool_size)]
+        return [random.choice(pool) for _ in range(n)]
+
 
-    steps_insertion = insertion_sort(data_insertion)
+## cal algo
+def get_algo_fn(name: str):
+    if name == "Insertion Sort":
+        return lambda arr: alg.insertion_sort(arr, record_steps=False)
+    if name == "Merge Sort":
+        return lambda arr: alg.merge_sort(arr, record_steps=False)
+    if name == "Quick Sort":
+        return lambda arr: alg.quick_sort(arr, record_steps=False)
+    if name == "Counting Sort":
+        return lambda arr: alg.counting_sort(arr, record_steps=False)
+    if name == "Radix Sort (LSD)":
+        return lambda arr: alg.radix_sort_lsd(arr, base=10, record_steps=False)
+    if name == "Heap Sort":
+        return lambda arr: alg.heap_sort(arr, record_steps=False)
+    if name == "Shell Sort":
+        return lambda arr: alg.shell_sort(arr, record_steps=False)
+    if name == "Bucket Sort":
+        return lambda arr: alg.bucket_sort(arr, record_steps=False)
+    raise ValueError(name)
 
-    steps_merge = merge_sort(data_merge)
 
-    st.subheader("Comparison Results")
-    col1, col2 = st.columns(2)
+if st.button("Run Scaling Benchmark"):
+    if not sizes:
+        st.error("Please enter at least one valid size (e.g., 10, 20, 40).")
+        st.stop()
 
-    with col1:
-        st.markdown("### Insertion Sort")
-        st.write(f"Total steps: {len(steps_insertion)}")
+    rows = []
+    for n in sizes:
+        for algo_name in selected_algos:
+            fn = get_algo_fn(algo_name)
+            times = []
+            for _ in range(runs_scale):
+                arr = make_data(n, input_type)
+                _, m = fn(arr)
+                times.append(m["seconds"] * 1000.0)  # ms
 
-    with col2:
-        st.markdown("### Merge Sort")
-        st.write(f"Total steps: {len(steps_merge)}")
+            avg_ms = statistics.mean(times)
+            std_ms = statistics.pstdev(times) if len(times) > 1 else 0.0
+
+            rows.append(
+                {
+                    "n": n,
+                    "Algorithm": algo_name,
+                    "Average Time (ms)": avg_ms,
+                    "Std Dev (ms)": std_ms,
+                }
+            )
+
+    df_scale = pd.DataFrame(rows)
+    fig_scale = go.Figure()
+
+    for algo_name in selected_algos:
+        sub = df_scale[df_scale["Algorithm"] == algo_name].sort_values("n")
+        fig_scale.add_trace(
+            go.Scatter(
+                x=sub["n"],
+                y=sub["Average Time (ms)"],
+                mode="lines+markers",
+                name=algo_name,
+            )
+        )
+    fig_scale.update_layout(
+        title=f"Scaling Benchmark (input_type = {input_type}, runs = {runs_scale})",
+        xaxis_title="n (input size)",
+        yaxis_title="Average Time (ms)",
+        height=480,
+        width=1000,
+    )
+    st.plotly_chart(fig_scale, use_container_width=True)
+
+    st.dataframe(
+        df_scale.sort_values(["Algorithm", "n"]).style.format(
+            {
+                "Average Time (ms)": "{:.3f}",
+                "Std Dev (ms)": "{:.3f}",
+            }
+        ),
+        use_container_width=True,
+    )
+
+    st.download_button(
+        "Download Scaling CSV",
+        data=df_scale.to_csv(index=False).encode("utf-8"),
+        file_name="scaling_benchmark.csv",
+        mime="text/csv",
+    )
+
+if st.button("Run Comparison"):
+
+    data_insertion = data.copy()
+    data_merge = data.copy()
+    data_quick = data.copy()
+    data_counting = data.copy()
+    data_radix = data.copy()
+    data_heap = data.copy()
+    data_shell = data.copy()
+    data_bucket = data.copy()
+
+    steps_insertion, metrics_insertion = alg.insertion_sort(data_insertion)
+    steps_merge, metrics_merge = alg.merge_sort(data_merge)
+    steps_quick, metrics_quick = alg.quick_sort(data_quick)
+    steps_counting, metrics_counting = alg.counting_sort(data_counting)
+    steps_radix, metrics_radix = alg.radix_sort_lsd(data_radix, base=10)
+    steps_heap, metrics_heap = alg.heap_sort(data_heap)
+    steps_shell, metrics_shell = alg.shell_sort(data_shell)
+    steps_bucket, metrics_bucket = alg.bucket_sort(data_bucket)
 
     def create_animation(steps, title, color_fn):
+        if not steps:
+            return go.Figure(
+                layout=go.Layout(
+                    width=900,
+                    height=420,
+                    title=title,
+                    xaxis=dict(visible=False),
+                    yaxis=dict(visible=False),
+                    annotations=[dict(text="No steps to display", showarrow=False)],
+                )
+            )
         frames = []
         for i, step in enumerate(steps):
             array = step["array"]
@@ -42,90 +225,289 @@ if st.button("Compare Insertion Sort vs Merge Sort"):
 
             colors = color_fn(len(array), active_index, sorted_boundary)
 
-            frames.append(go.Frame(
-                data=[go.Scatter(
-                    x=list(range(len(array))),
-                    y=array,
-                    mode="markers+text",
-                    marker=dict(size=40, color=colors),
-                    text=array,
-                    textposition="middle center"
-                )],
-                name=f"Step {i+1}"
-            ))
+            frames.append(
+                go.Frame(
+                    data=[
+                        go.Scatter(
+                            x=list(range(len(array))),
+                            y=array,
+                            mode="markers+text",
+                            marker=dict(size=28, color=colors),
+                            text=array,
+                            textposition="middle center",
+                        )
+                    ],
+                    name=f"Step {i+1}",
+                )
+            )
 
         initial = steps[0]
-        initial_colors = color_fn(len(initial["array"]),
-                                  initial.get("active_index", -1),
-                                  initial.get("sorted_boundary", -1))
+        initial_colors = color_fn(
+            len(initial["array"]),
+            initial.get("active_index", -1),
+            initial.get("sorted_boundary", -1),
+        )
 
         fig = go.Figure(
-            data=[go.Scatter(
-                x=list(range(len(initial["array"]))),
-                y=initial["array"],
-                mode="markers+text",
-                marker=dict(size=40, color=initial_colors),
-                text=initial["array"],
-                textposition="middle center"
-            )],
+            data=[
+                go.Scatter(
+                    x=list(range(len(initial["array"]))),
+                    y=initial["array"],
+                    mode="markers+text",
+                    marker=dict(size=28, color=initial_colors),
+                    text=initial["array"],
+                    textposition="middle center",
+                )
+            ],
             layout=go.Layout(
-                height=400,
+                width=900,
+                height=420,
                 title=title,
                 xaxis=dict(range=[-0.5, len(initial["array"]) - 0.5]),
-                yaxis=dict(range=[0, max(max(s['array']) for s in steps) + 5]),
-                updatemenus=[dict(
-                    type="buttons",
-                    buttons=[dict(label="Play", method="animate", args=[None])],
-                    showactive=False
-                )],
-                sliders=[{
-                    "steps": [{
-                        "args": [[f"Step {i+1}"], {"frame": {"duration": 500, "redraw": True}}],
-                        "label": f"{i+1}",
-                        "method": "animate"
-                    } for i in range(len(frames))],
-                    "transition": {"duration": 0},
-                    "x": 0, "y": -0.1,
-                    "currentvalue": {"prefix": "Step: "}
-                }]
+                yaxis=dict(range=[0, max(max(s["array"]) for s in steps) + 5]),
+                updatemenus=[
+                    dict(
+                        type="buttons",
+                        buttons=[dict(label="Play", method="animate", args=[None])],
+                        showactive=False,
+                    )
+                ],
+                sliders=[
+                    {
+                        "steps": [
+                            {
+                                "args": [
+                                    [f"Step {i+1}"],
+                                    {"frame": {"duration": 500, "redraw": True}},
+                                ],
+                                "label": f"{i+1}",
+                                "method": "animate",
+                            }
+                            for i in range(len(frames))
+                        ],
+                        "transition": {"duration": 0},
+                        "x": 0,
+                        "y": -0.1,
+                        "currentvalue": {"prefix": "Step: "},
+                    }
+                ],
             ),
-            frames=frames
+            frames=frames,
         )
         return fig
 
     def insertion_colors(length, active_index, sorted_boundary):
         return [
-            "red" if j == active_index else
-            "green" if j <= sorted_boundary else "gray"
+            (
+                "red"
+                if j == active_index
+                else "green" if j <= sorted_boundary else "gray"
+            )
             for j in range(length)
         ]
 
     def merge_colors(length, active_index, sorted_boundary):
         return [
-            "purple" if j == active_index else
-            "blue" if j <= sorted_boundary else "gray"
+            (
+                "purple"
+                if j == active_index
+                else "blue" if j <= sorted_boundary else "gray"
+            )
+            for j in range(length)
+        ]
+
+    def quick_colors(length, active_index, sorted_boundary):
+        return [
+            (
+                "orange"
+                if j == active_index
+                else "green" if j == sorted_boundary else "gray"
+            )
+            for j in range(length)
+        ]
+
+    def counting_colors(length, active_index, sorted_boundary):
+        return [
+            (
+                "purple"
+                if j == active_index
+                else "green" if j == sorted_boundary else "gray"
+            )
+            for j in range(length)
+        ]
+
+    def radix_colors(length, active_index, sorted_boundary):
+        return [
+            (
+                "purple"
+                if j == active_index
+                else "green" if j <= sorted_boundary else "gray"
+            )
+            for j in range(length)
+        ]
+
+    def heap_colors(length, active_index, sorted_boundary):
+        return [
+            (
+                "orange"
+                if j == active_index
+                else (
+                    "green"
+                    if (sorted_boundary != -1 and j >= sorted_boundary)
+                    else "gray"
+                )
+            )
+            for j in range(length)
+        ]
+
+    def shell_colors(length, active_index, sorted_boundary):
+        return [("orange" if j == active_index else "gray") for j in range(length)]
+
+    def bucket_colors(length, active_index, sorted_boundary):
+        return [
+            (
+                "purple"
+                if j == active_index
+                else "green" if j <= sorted_boundary else "gray"
+            )
             for j in range(length)
         ]
 
-    st.plotly_chart(create_animation(steps_insertion, "Insertion Sort", insertion_colors))
-
-    st.plotly_chart(create_animation(steps_merge, "Merge Sort", merge_colors))
-
-    st.subheader("About the Algorithms")
-    st.markdown("**Insertion Sort**")
-    st.markdown("""
-    - Simple comparison-based sorting algorithm  
-    - Builds the sorted array one element at a time  
-    - In-place and stable  
-    - Best case: Θ(n) when the array is already sorted  
-    - Worst case: Θ(n²) when the array is reverse sorted  
-    """)
-
-    st.markdown("**Merge Sort**")
-    st.markdown("""
-    - Divide-and-conquer algorithm  
-    - Recursively splits the array and merges sorted halves  
-    - Stable but not in-place  
-    - Consistently performs in Θ(n log n) time in all cases  
-    - Requires additional memory for merging  
-    """)
+    (
+        tab_ins,
+        tab_mer,
+        tab_quick,
+        tab_count,
+        tab_radix,
+        tab_heap,
+        tab_shell,
+        tab_bucket,
+    ) = st.tabs(
+        [
+            "Insertion",
+            "Merge",
+            "Quick",
+            "Counting",
+            "Radix (LSD)",
+            "Heap",
+            "Shell",
+            "Bucket",
+        ]
+    )
+
+    with tab_ins:
+        st.plotly_chart(
+            create_animation(steps_insertion, "Insertion Sort", insertion_colors),
+            use_container_width=True,
+        )
+    with tab_mer:
+        st.plotly_chart(
+            create_animation(steps_merge, "Merge Sort", merge_colors),
+            use_container_width=True,
+        )
+    with tab_quick:
+        st.plotly_chart(
+            create_animation(steps_quick, "Quick Sort", quick_colors),
+            use_container_width=True,
+        )
+    with tab_count:
+        st.plotly_chart(
+            create_animation(steps_counting, "Counting Sort", counting_colors),
+            use_container_width=True,
+        )
+    with tab_radix:
+        st.plotly_chart(
+            create_animation(steps_radix, "Radix Sort (LSD)", radix_colors),
+            use_container_width=True,
+        )
+    with tab_heap:
+        st.plotly_chart(
+            create_animation(steps_heap, "Heap Sort", heap_colors),
+            use_container_width=True,
+        )
+    with tab_shell:
+        st.plotly_chart(
+            create_animation(steps_shell, "Shell Sort", shell_colors),
+            use_container_width=True,
+        )
+    with tab_bucket:
+        st.plotly_chart(
+            create_animation(steps_bucket, "Bucket Sort", bucket_colors),
+            use_container_width=True,
+        )
+
+    df = pd.DataFrame(
+        [
+            {
+                "Algorithm": "Insertion Sort",
+                "Time (ms)": metrics_insertion["seconds"] * 1000,
+                "Comparisons": metrics_insertion["comparisons"],
+                "Moves": metrics_insertion["moves"],
+                "Frames": len(steps_insertion),
+                "Sorted OK": steps_insertion[-1]["array"] == sorted(data),
+            },
+            {
+                "Algorithm": "Merge Sort",
+                "Time (ms)": metrics_merge["seconds"] * 1000,
+                "Comparisons": metrics_merge["comparisons"],
+                "Moves": metrics_merge["moves"],
+                "Frames": len(steps_merge),
+                "Sorted OK": steps_merge[-1]["array"] == sorted(data),
+            },
+            {
+                "Algorithm": "Quick Sort",
+                "Time (ms)": metrics_quick["seconds"] * 1000,
+                "Comparisons": metrics_quick["comparisons"],
+                "Moves": metrics_quick["moves"],
+                "Frames": len(steps_quick),
+                "Sorted OK": steps_quick[-1]["array"] == sorted(data),
+            },
+            {
+                "Algorithm": "Counting Sort",
+                "Time (ms)": metrics_counting["seconds"] * 1000,
+                "Comparisons": metrics_counting["comparisons"],
+                "Moves": metrics_counting["moves"],
+                "Frames": len(steps_counting),
+                "Sorted OK": steps_counting[-1]["array"] == sorted(data),
+            },
+            {
+                "Algorithm": "Radix Sort(LSD)",
+                "Time (ms)": metrics_radix["seconds"] * 1000,
+                "Comparisons": metrics_radix["comparisons"],
+                "Moves": metrics_radix["moves"],
+                "Frames": len(steps_radix),
+                "Sorted OK": steps_radix[-1]["array"] == sorted(data),
+            },
+            {
+                "Algorithm": "Heap Sort",
+                "Time (ms)": metrics_heap["seconds"] * 1000,
+                "Comparisons": metrics_heap["comparisons"],
+                "Moves": metrics_heap["moves"],
+                "Frames": len(steps_heap),
+                "Sorted OK": steps_heap[-1]["array"] == sorted(data),
+            },
+            {
+                "Algorithm": "Shell Sort",
+                "Time (ms)": metrics_shell["seconds"] * 1000,
+                "Comparisons": metrics_shell["comparisons"],
+                "Moves": metrics_shell["moves"],
+                "Frames": len(steps_shell),
+                "Sorted OK": steps_shell[-1]["array"] == sorted(data),
+            },
+            {
+                "Algorithm": "Bucket Sort",
+                "Time (ms)": metrics_bucket["seconds"] * 1000,
+                "Comparisons": metrics_bucket["comparisons"],
+                "Moves": metrics_bucket["moves"],
+                "Frames": len(steps_bucket),
+                "Sorted OK": steps_bucket[-1]["array"] == sorted(data),
+            },
+        ]
+    )
+    st.subheader("Summary Table")
+    st.dataframe(df.style.format({"Time (ms)": "{:.2f}"}), use_container_width=True)
+
+    csv = df.to_csv(index=False).encode("utf-8")
+    st.download_button(
+        "Download CSV", data=csv, file_name="sorting_summary.csv", mime="text/csv"
+    )

notes.py

@@ -0,0 +1,41 @@
+# insertion sort
+
+def insertion_sort(arr):
+    steps = []  # keep all steps here
+
+    for j in range(1, len(arr)):
+        key = arr[j]
+        i = j - 1
+
+        while i >= 0 and arr[i] > key:
+            arr[i + 1] = arr[i]
+            i -= 1
+            steps.append(arr.copy())  # her kaydırma adımını kaydet
+        arr[i + 1] = key
+        steps.append(arr.copy())  # save every moment
+        # arr listesini sıralıyor
+        # Ama her küçük değişiklikten sonra o anki halini steps listesine ekliyor
+
+    return steps
+
+# nested listeler için deepcopy()
+# Liste içinde başka listeler varsa, onları da ayrı ayrı kopyalar
+
+from algorithms import insertion_sort
+
+my_list=[5,2,4,6,1,3]
+
+steps = insertion_sort(my_list)
+
+for i, step in enumerate(steps):
+    print(f"Step {i + 1}: {step}")
+
+# 	enumerate(steps) → Hem adımı (i) hem listeyi (step) aynı anda alır
+# 	Her sıralama adımı steps içinde kayıtlı olduğu için tüm sıralama sürecini gözlemleyebiliriz
+# 	Bu yapı daha sonra Streamlit arayüzüne kolayca taşınabilir
+
+def print_step(step):
+    for num in step:
+        bar = '█' * num  # Sayıya göre bar uzunluğu
+        print(f"{num:>2} {bar}")
+    print("-" * 20)  # Adımlar arasında ayraç

requirements.txt

@@ -1,4 +1,4 @@
 streamlit>=1.25.0,<2.0.0
 plotly>=5.18.0
 numpy<=1.26.4
-matplotlib
+matplotlib>=3.7.0