refactor: move sorting classes from test to main source set

2026-08-25 23:14:35 +04:00
parent dfd6ab9ce6
commit 4d20a59072
5 changed files with 0 additions and 0 deletions
@@ -0,0 +1,65 @@
+package sorting;
+
+import java.util.Comparator;
+
+public class MergeSortStrategy<T> implements SortStrategy<T> {
+
+    @Override
+    public void sort(MyList<T> list, Comparator<T> comparator) {
+        if (list == null || list.size() <= 1) {
+            return;
+        }
+        mergeSort(list, 0, list.size() - 1, comparator);
+    }
+
+    private void mergeSort(MyList<T> list, int left, int right, Comparator<T> comparator) {
+        if (left >= right) {
+            return;
+        }
+        int mid = (left + right) / 2;
+        mergeSort(list, left, mid, comparator);
+        mergeSort(list, mid + 1, right, comparator);
+        merge(list, left, mid, right, comparator);
+    }
+
+    private void merge(MyList<T> list, int left, int mid, int right, Comparator<T> comparator) {
+        int leftSize = mid - left + 1;
+        int rightSize = right - mid;
+
+        @SuppressWarnings("unchecked")
+        T[] leftArray = (T[]) new Object[leftSize];
+        @SuppressWarnings("unchecked")
+        T[] rightArray = (T[]) new Object[rightSize];
+
+        for (int i = 0; i < leftSize; i++) {
+            leftArray[i] = list.get(left + i);
+        }
+        for (int j = 0; j < rightSize; j++) {
+            rightArray[j] = list.get(mid + 1 + j);
+        }
+
+        int i = 0, j = 0, k = left;
+
+        while (i < leftSize && j < rightSize) {
+            if (comparator.compare(leftArray[i], rightArray[j]) <= 0) {
+                list.set(k, leftArray[i]);
+                i++;
+            } else {
+                list.set(k, rightArray[j]);
+                j++;
+            }
+            k++;
+        }
+
+        while (i < leftSize) {
+            list.set(k, leftArray[i]);
+            i++;
+            k++;
+        }
+        while (j < rightSize) {
+            list.set(k, rightArray[j]);
+            j++;
+            k++;
+        }
+    }
+}
@@ -0,0 +1,7 @@
+package sorting;
+
+import java.util.Comparator;
+
+public interface SortStrategy<T> {
+    void sort(MyList<T> list, Comparator<T> comparator);
+}
@@ -0,0 +1,11 @@
+package sorting;
+
+import java.util.Comparator;
+
+public class StudentAvarageGradeComparator implements Comparator<Student> {
+
+    @Override
+    public int compare(Student s1, Student s2) {
+        return Double.compare(s1.getAvarageGrade(), s2.getAvarageGrade());
+    }
+}
@@ -0,0 +1,11 @@
+package sorting;
+
+import java.util.Comparator;
+
+public class StudentGroupComparator implements Comparator<Student> {
+
+    @Override
+    public String compare(Student s1, Student s2) {
+        return Integer.compare(s1.getGroupNumber(), s2.getGroupNumber());
+    }
+}
@@ -0,0 +1,11 @@
+package sorting;
+
+import java.util.Comparator;
+
+public class StudentRecordBookComparator implements Comparator<Student> {
+
+    @Override
+    public int compare(Student s1, Student s2) {
+        return Integer.compare(s1.getRecordBookNumber(), s2.getRecordBookNumber());
+    }
+}