Bubble sort

Bubble sort este o metodă simplă de sortare a unui vector sau a unei liste de elemente.
Metoda funcționează prin parcurgerea repetată a listei și compararea fiecărui element cu
următorul element, apoi inversarea pozițiilor lor dacă acestea sunt în ordine inversă. Acest
proces continuă până când toate elementele sunt sortate.
Bubble sort este o metodă de sortare ineficientă pentru liste mari sau vectori mari,
deoarece necesită un număr mare de comparații și inversiuni de elemente. În timpul
fiecărei parcurgeri a listei, cel puțin un element va fi plasat în poziția sa finală, ceea ce
înseamnă că numărul de parcurgeri necesare este egal cu numărul de elemente care nu
sunt încă în poziția lor finală.
Deși bubble sort este o metodă de sortare simplă, există multe alte metode mai eficiente
și mai rapide de sortare, cum ar fi quicksort și mergesort.

public class BubbleSort {

public static void bubbleSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// schimba elementele
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}

public static void main(String[] args) {

int[] arr = {64, 34, 25, 12, 22, 11, 90};

System.out.println("Array nesortat:");
for (int i : arr) {
System.out.print(i + " ");
}
 bubbleSort(arr);

System.out.println("\nArray sortat:");
for (int i : arr) {
System.out.print(i + " ");
}
}
}
Această implementare va sorta vectorul dat prin utilizarea algoritmului Bubble Sort. Prin
intermediul metodei bubbleSort(), fiecare element din vector este comparat cu celălalt și
este inversat dacă este necesar, iar acest proces se repetă până când toate elementele sunt
în ordine.
Bubble Sort este o metodă simplă de sortare care funcționează prin compararea repetată
a fiecărui element dintr-un vector cu următorul element și inversarea lor dacă nu sunt în
ordine corectă.
Imaginează că ai un set de cărți nesortate pe o masă și trebuie să le sortezi în ordine
crescătoare după numărul de pagini. Dacă ai folosi metoda Bubble Sort, ai începe prin a
compara prima carte cu cea de-a doua carte. Dacă prima carte are mai multe pagini decât
a doua carte, le-ai inversa pozițiile astfel încât prima carte să fie acum după cea de-a doua
carte. Apoi ai compara cea de-a doua carte cu a treia carte și așa mai departe, până la
ultima carte. La sfârșitul primei iterații, cel mai mare număr de pagini ar fi acum la
sfârșitul vectorului.
Apoi, în următoarea iterație, ai începe de la începutul vectorului și ai face aceeași
comparație și inversare dacă este necesar, astfel încât al doilea număr cel mai mare de
pagini să fie acum pe penultima poziție din vector. Acest proces continuă până când toate
elementele sunt sortate.
Bubble Sort poate fi ușor de înțeles, dar poate fi destul de lent pentru liste sau vectori
mari. Cu toate acestea, este util în cazul unor mici liste sau vectori, sau în cazul în care
trebuie să sortați o listă aproape sortată deja.
Regenerate response
Selection Sort
Selection Sort este un algoritm de sortare care funcționează prin găsirea elementului
minim dintr-un vector nesortat și plasarea sa pe prima poziție. Acest proces se repetă
pentru fiecare poziție din vector, astfel încât la sfârșit, toate elementele sunt în ordine
crescătoare.
Mai precis, pentru a implementa Selection Sort pe un vector, vom parcurge vectorul și
pentru fiecare poziție i, vom găsi elementul minim dintre elementele rămase nesortate în
intervalul [i, n), unde n este dimensiunea vectorului. Acest element minim va fi apoi
plasat pe poziția i. În acest fel, vectorul se va împărți într-o parte sortată (primele i
elemente) și o parte nesortată (restul de n - i elemente), iar acest proces se va repeta pentru
fiecare poziție i până când întregul vector este sortat.
Selection Sort este un algoritm simplu de implementat și are o complexitate a timpului
de execuție de O(n^2), unde n este numărul de elemente din vector. Deși nu este atât de
eficient ca alți algoritmi de sortare, cum ar fi QuickSort sau MergeSort, Selection Sort
poate fi util în anumite situații, cum ar fi sortarea unui vector mic sau sortarea unui vector
parțial sortat.
public class SelectionSort {
public static void selectionSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
int temp = arr[minIndex];
arr[minIndex] = arr[i];
arr[i] = temp;
}
}

public static void main(String[] args) {

int[] arr = {64, 34, 25, 12, 22, 11, 90};
 System.out.println("Array nesortat:");
for (int i : arr) {
System.out.print(i + " ");
}

selectionSort(arr);

System.out.println("\nArray sortat:");
for (int i : arr) {
System.out.print(i + " ");
}
}
}
Această implementare va sorta vectorul dat prin utilizarea algoritmului Selection Sort.
Prin intermediul metodei selectionSort(), fiecare element din vector este comparat cu
celelalte elemente rămase nesortate, pentru a găsi cel mai mic element. Acest element
este apoi plasat în partea sortată a vectorului, iar acest proces se repetă până când toate
elementele sunt în ordine.

Insertion Sort
Insertion Sort este un algoritm de sortare eficient pentru liste sau vectori relativ mici.
Acesta împarte lista nesortată într-o parte sortată și o parte nesortată. La fiecare pas,
algoritmul extrage un element din partea nesortată și îl plasează în locul potrivit din partea
sortată, astfel încât partea sortată să fie cu un element mai mare.
Mai precis, pentru a implementa Insertion Sort, vom împărți lista nesortată într-o parte
sortată și o parte nesortată. În fiecare iterație, extragem primul element din partea
nesortată și îl inserăm în locul potrivit din partea sortată. Pentru a găsi locul potrivit pentru
elementul extras, vom compara acest element cu celelalte elemente din partea sortată,
începând de la sfârșit și mergând către începutul listei. În timpul parcurgerii listei sortate,
fiecare element mai mare decât elementul extras va fi mutat la dreapta cu o poziție, astfel
încât elementul extras să poată fi inserat în locul său potrivit.
Insertion Sort este un algoritm stabil (păstrează ordinea relativă a elementelor egale) și
are o complexitate a timpului de execuție de O(n^2), unde n este numărul de elemente
din listă sau vector. Deși nu este atât de eficient ca alți algoritmi de sortare, cum ar fi
QuickSort sau MergeSort, Insertion Sort poate fi util în anumite situații, cum ar fi sortarea
unui vector mic sau sortarea unui vector aproape sortat.
public class InsertionSort {
public static void insertionSort(int[] arr) {
int n = arr.length;
for (int i = 1; i < n; i++) {
int key = arr[i];
int j = i - 1;

while (j >= 0 && arr[j] > key) {

arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}

public static void main(String[] args) {

int[] arr = {64, 34, 25, 12, 22, 11, 90};

System.out.println("Array nesortat:");
for (int i : arr) {
System.out.print(i + " ");
}

insertionSort(arr);

System.out.println("\nArray sortat:");
for (int i : arr) {
System.out.print(i + " ");
}
}
}
Această implementare va sorta vectorul dat prin utilizarea algoritmului Insertion Sort.
Prin intermediul metodei insertionSort(), fiecare element din vector este extrase unul
câte unul și inserat în partea sortată a vectorului. Pentru a găsi locul potrivit pentru fiecare
element extras, algoritmul compară acest element cu celelalte elemente din partea sortată,
începând de la sfârșit și mergând către începutul listei.
Această implementare are o complexitate a timpului de execuție de O(n^2), dar poate fi
optimizată prin utilizarea unor tehnici precum sortarea prin grupe și sortarea prin inserție
binară.

Merge Sort
Merge Sort este un algoritm de sortare recursiv, care utilizează o abordare divide-et-
impera. Acest algoritm împarte lista nesortată în două părți egale, apoi sortază fiecare
jumătate recursiv prin împărțirea și sortarea fiecărei jumătăți. Ulterior, cele două jumătăți
sortate sunt combinate într-o singură listă sortată.
Mai precis, Merge Sort împarte lista nesortată în două părți egale și aplică recursiv același
proces de sortare pe fiecare dintre aceste jumătăți. Atunci când ajunge la cazul de bază
(lista este formată din un singur element), cele două liste sortate sunt combinate pentru a
forma o singură listă sortată. Pentru a combina cele două liste sortate, Merge Sort compară
primul element din fiecare dintre cele două liste și le plasează în ordine crescătoare în
lista sortată finală. Procesul continuă astfel încât fiecare element din ambele liste este
sortat și plasat în ordinea corectă în lista finală.
Merge Sort este un algoritm stabil și are o complexitate a timpului de execuție de O(n log
n), unde n este numărul de elemente din listă sau vector. Deși poate fi mai lent decât
algoritmi precum QuickSort sau HeapSort, Merge Sort este util atunci când este nevoie
de stabilitate și/sau de a sorta liste sau vectori mai mari.

public class MergeSort {

public static void mergeSort(int[] arr, int left, int right) {
if (left < right) {
int middle = (left + right) / 2;

mergeSort(arr, left, middle);

mergeSort(arr, middle + 1, right);

merge(arr, left, middle, right);

}
}
public static void merge(int[] arr, int left, int middle, int right) {
int n1 = middle - left + 1;
int n2 = right - middle;

int[] L = new int[n1];

int[] R = new int[n2];

for (int i = 0; i < n1; ++i) {

L[i] = arr[left + i];
}
for (int j = 0; j < n2; ++j) {
R[j] = arr[middle + 1 + j];
}

int i = 0, j = 0;
int k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}

while (i < n1) {

arr[k] = L[i];
i++;
k++;
}

while (j < n2) {

 arr[k] = R[j];
j++;
k++;
}
}

public static void main(String[] args) {

int[] arr = {64, 34, 25, 12, 22, 11, 90};

System.out.println("Array nesortat:");
for (int i : arr) {
System.out.print(i + " ");
}

mergeSort(arr, 0, arr.length - 1);

System.out.println("\nArray sortat:");
for (int i : arr) {
System.out.print(i + " ");
}
}
}
Această implementare va sorta vectorul dat prin utilizarea algoritmului Merge Sort. Prin
intermediul metodei mergeSort(), vectorul este împărțit în mod recursiv în două jumătăți
egale, sortate separat prin apeluri recursive ale funcției și apoi combinate într-un vector
sortat prin utilizarea metodei merge(). Implementarea este o versiune iterativă a
algoritmului și folosește trei indici: left, middle și right. În plus, se folosesc două vectori
intermediari, L și R, pentru a stoca fiecare jumătate a vectorului.
Această implementare are o complexitate a timpului de execuție de O(n log n) și poate fi
utilizată pentru a sorta orice tip de vector care implementează interfața Comparable.
Quick Sort
Quick Sort este un algoritm de sortare care utilizează o strategie "împarte și cucerește"
pentru a sorta un vector. Ideea principală a algoritmului constă în a alege un element din
vector, numit pivot, și apoi să se împartă vectorul în două sub-vectori: unul care conține
toate elementele mai mici decât pivotul și unul care conține toate elementele mai mari
decât pivotul. Această operație se numește partitioning. Apoi, algoritmul este recursiv
aplicat la cele două sub-vectori până când toate elementele sunt sortate.
Implementarea Quicksort-ului poate fi realizată printr-o funcție recursivă, care primește
ca parametri un vector, indicele din stânga și cel din dreapta și are ca scop sortarea
vectorului între acești doi indici. Partiționarea se face astfel: se alege un element pivot
din vector, apoi se mută toate elementele mai mici decât pivotul în stânga sa, iar cele mai
mari decât pivotul în dreapta sa. Astfel, pivotul va fi poziționat în locația sa finală și va fi
fixat acolo. Algoritmul apoi este recursiv aplicat la cele două sub-vectori create prin
partitioning.
Iată o implementare a algoritmului Quick Sort în Java:

public class QuickSort {

public static void quickSort(int[] arr, int left, int right) {
if (left < right) {
int pivotIndex = partition(arr, left, right);
quickSort(arr, left, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, right);
}
}

public static int partition(int[] arr, int left, int right) {

int pivot = arr[right];
int i = left - 1;

for (int j = left; j < right; j++) {

if (arr[j] < pivot) {
i++;
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
 }
}

int temp = arr[i + 1];

arr[i + 1] = arr[right];
arr[right] = temp;

return i + 1;
}

public static void main(String[] args) {

int[] arr = {64, 34, 25, 12, 22, 11, 90};

System.out.println("Array nesortat:");
for (int i : arr) {
System.out.print(i + " ");
}

quickSort(arr, 0, arr.length - 1);

System.out.println("\nArray sortat:");
for (int i : arr) {
System.out.print(i + " ");
}
}
}
Această implementare va sorta vectorul dat prin utilizarea algoritmului Quick Sort. Prin
intermediul metodei quickSort(), vectorul este împărțit în mod recursiv în două sub-
vectori, sortați separat prin apeluri recursive ale funcției și apoi combinați într-un vector
sortat prin utilizarea metodei partition(). Partiționarea se face prin alegerea pivotului și
mutarea elementelor mai mici decât pivotul în stânga sa și cele