Skip to content

Commit eab27e1

Browse files
timbslrtimbslr
authored
Refactored most of the code for a better readability
1 parent 339982d commit eab27e1

25 files changed

+899
-0
lines changed

‎src/main/java/Algorithms/BubbleSort.java‎

Lines changed: 45 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,45 @@
1+
package main.java.Algorithms;
2+
3+
import javax.swing.SwingWorker;
4+
import main.java.Bar;
5+
import main.java.Settings;
6+
import main.java.SortingAlgorithm;
7+
import main.java.SortingOrder;
8+
import main.java.FrameComponents.ViewPort;
9+
10+
public class BubbleSort extends SortingAlgorithm{ //O(n^2)
11+
12+
Bar[] ar = getArray();
13+
14+
public BubbleSort(Bar[] in) {
15+
super(in);
16+
}
17+
18+
@Override
19+
public void sort(SortingOrder so) {
20+
SwingWorker<Void, String> Worker = new SwingWorker<Void, String>(){
21+
22+
@Override
23+
protected Void doInBackground() throws Exception {
24+
for(int i = 0; i < ar.length -1; i++) {
25+
for(int j = 0; j < ar.length -i -1; j++) {
26+
if(so == SortingOrder.LtoH) {
27+
if(ar[j].value > ar[j+1].value) {
28+
swapBars(ViewPort.bars[j], ViewPort.bars[j+1]);
29+
Thread.sleep(Settings.sortingDelay);
30+
}
31+
} else if(so == SortingOrder.HtoL) {
32+
if(ar[j].value < ar[j+1].value) {
33+
swapBars(ViewPort.bars[j], ViewPort.bars[j+1]);
34+
Thread.sleep(Settings.sortingDelay);
35+
}
36+
}
37+
}
38+
}
39+
return null;
40+
}
41+
};
42+
Worker.execute();
43+
}
44+
45+
}

‎src/main/java/Algorithms/HeapSort.java‎

Lines changed: 70 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,70 @@
1+
package main.java.Algorithms;
2+
3+
import javax.swing.SwingWorker;
4+
import main.java.Bar;
5+
import main.java.Settings;
6+
import main.java.SortingAlgorithm;
7+
import main.java.SortingOrder;
8+
9+
public class HeapSort extends SortingAlgorithm{
10+
11+
Bar[] ar = getArray();
12+
13+
public HeapSort(Bar[] in) {
14+
super(in);
15+
}
16+
17+
@Override
18+
public void sort(SortingOrder so) {
19+
SwingWorker<Void, String> Worker = new SwingWorker<Void, String>(){
20+
21+
@Override
22+
protected Void doInBackground() throws Exception {
23+
int size = ar.length;
24+
25+
for(int i = size/2-1; i>=0; i--) {
26+
heapify(so, ar, size, i);
27+
}
28+
29+
for(int i=size-1; i>=0; i--) {
30+
swapBars(ar[0], ar[i]);
31+
Thread.sleep(Settings.sortingDelay);
32+
heapify(so, ar, i, 0);
33+
}
34+
return null;
35+
}
36+
};
37+
Worker.execute();
38+
}
39+
40+
void heapify(SortingOrder so, Bar array[], int size, int i) throws Exception{
41+
int largest = i;
42+
int l = 2*i+1;
43+
int r = 2*i+2;
44+
if(so == SortingOrder.LtoH) {
45+
if(l<size && array[l].value > array[largest].value) {
46+
largest = l;
47+
}
48+
49+
if(r<size && array[r].value > array[largest].value) {
50+
largest = r;
51+
}
52+
} else if(so == SortingOrder.HtoL){
53+
if(l<size && array[l].value < array[largest].value) {
54+
largest = l;
55+
}
56+
57+
if(r<size && array[r].value < array[largest].value) {
58+
largest = r;
59+
}
60+
}
61+
62+
if(largest != i) {
63+
swapBars(array[i], array[largest]);
64+
Thread.sleep(Settings.sortingDelay);
65+
heapify(so, array, size, largest);
66+
}
67+
68+
}
69+
70+
}

‎src/main/java/Algorithms/InsertionSort.java‎

Lines changed: 57 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,57 @@
1+
package main.java.Algorithms;
2+
3+
import javax.swing.SwingWorker;
4+
import main.java.Bar;
5+
import main.java.Settings;
6+
import main.java.SortingAlgorithm;
7+
import main.java.SortingOrder;
8+
import main.java.FrameComponents.ViewPort;
9+
10+
public class InsertionSort extends SortingAlgorithm { //O(n^2), best case O(n)
11+
12+
Bar[] ar = getArray();
13+
14+
public InsertionSort(Bar[] in) {
15+
super(in);
16+
}
17+
18+
@Override
19+
public void sort(SortingOrder so) {
20+
SwingWorker<Void, String> Worker = new SwingWorker<Void, String>(){
21+
22+
@Override
23+
protected Void doInBackground() throws Exception {
24+
for(int i = 1; i < ar.length; i++) {
25+
int temp = ViewPort.bars[i].value;
26+
int j = i - 1;
27+
28+
if(so == SortingOrder.LtoH) {
29+
while(j >= 0 && ar[j].value > temp) {
30+
ViewPort.bars[j+1].value = ViewPort.bars[j].value;
31+
ViewPort.bars[j+1].panel.setBounds(0,Settings.allBarsPanelHeigth-ViewPort.bars[j+1].value,1000,ViewPort.bars[j+1].value);
32+
Thread.sleep(Settings.sortingDelay);
33+
j--;
34+
}
35+
} else if(so == SortingOrder.HtoL) {
36+
while(j >= 0 && ar[j].value < temp) {
37+
ViewPort.bars[j+1].value = ViewPort.bars[j].value;
38+
ViewPort.bars[j+1].panel.setBounds(0,Settings.allBarsPanelHeigth-ViewPort.bars[j+1].value,1000,ViewPort.bars[j+1].value);
39+
Thread.sleep(Settings.sortingDelay);
40+
j--;
41+
}
42+
}
43+
44+
ar[j+1].value = temp;
45+
ViewPort.bars[j+1].value = temp;
46+
ViewPort.bars[j+1].panel.setBounds(0,Settings.allBarsPanelHeigth-ViewPort.bars[j+1].value,1000,ViewPort.bars[j+1].value);
47+
Thread.sleep(Settings.sortingDelay);
48+
}
49+
return null;
50+
}
51+
};
52+
Worker.execute();
53+
54+
}
55+
56+
57+
}

‎src/main/java/Algorithms/MergeSort.java‎

Lines changed: 120 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,120 @@
1+
package main.java.Algorithms;
2+
3+
import javax.swing.JPanel;
4+
import javax.swing.SwingWorker;
5+
import main.java.Bar;
6+
import main.java.Settings;
7+
import main.java.SortingAlgorithm;
8+
import main.java.SortingOrder;
9+
import main.java.FrameComponents.ViewPort;
10+
11+
public class MergeSort extends SortingAlgorithm{ //O(n log n), but more space
12+
13+
Bar[] ar = getArray();
14+
public MergeSort(Bar[] in) {
15+
super(in);
16+
}
17+
18+
@Override
19+
public void sort(SortingOrder so) {
20+
SwingWorker<Void, String> Worker = new SwingWorker<Void, String>(){
21+
22+
@Override
23+
protected Void doInBackground() throws Exception {
24+
mergeSort(ar, so);
25+
return null;
26+
}
27+
};
28+
Worker.execute();
29+
}
30+
31+
void mergeSort(Bar[] ar, SortingOrder so) throws Exception{
32+
33+
int length = ar.length;
34+
if(length <= 1) return; //base case
35+
36+
int middle = length / 2;
37+
Bar[] leftArray = new Bar[middle];
38+
for(int i = 0; i<leftArray.length; i++) {
39+
leftArray[i] = new Bar(new JPanel(), 10);
40+
}
41+
42+
Bar[] rightArray = new Bar[length - middle];
43+
for(int i = 0; i<rightArray.length; i++) {
44+
rightArray[i] = new Bar(new JPanel(), 10);
45+
}
46+
47+
int j = 0; //for rightArray
48+
49+
for(int l = 0;l < length; l++) {
50+
if(l < middle) {
51+
leftArray[l].value = ar[l].value;
52+
} else {
53+
rightArray[j].value = ar[l].value;
54+
j++;
55+
}
56+
}
57+
mergeSort(leftArray, so);
58+
mergeSort(rightArray, so);
59+
merge(leftArray, rightArray, ar, so);
60+
}
61+
62+
void merge(Bar[] leftArray, Bar[] rightArray, Bar[] ar, SortingOrder so) throws Exception{
63+
int leftSize = ar.length / 2;
64+
int rightSize = ar.length - leftSize;
65+
int i = 0, l = 0, r = 0; //indices
66+
67+
while(l < leftSize && r < rightSize) {
68+
if(so==SortingOrder.LtoH) {
69+
if(leftArray[l].value < rightArray[r].value) {
70+
ar[i].value = leftArray[l].value;
71+
ViewPort.bars[i].value = leftArray[l].value;
72+
ViewPort.bars[i].panel.setBounds(0,Settings.allBarsPanelHeigth-ViewPort.bars[i].value,1000,ViewPort.bars[i].value);
73+
Thread.sleep(Settings.sortingDelay);
74+
i++;
75+
l++;
76+
} else {
77+
ar[i].value = rightArray[r].value;
78+
ViewPort.bars[i].value = rightArray[r].value;
79+
ViewPort.bars[i].panel.setBounds(0,Settings.allBarsPanelHeigth-ViewPort.bars[i].value,1000,ViewPort.bars[i].value);
80+
Thread.sleep(Settings.sortingDelay);
81+
i++;
82+
r++;
83+
}
84+
} else {
85+
if(leftArray[l].value > rightArray[r].value) {
86+
ar[i].value = leftArray[l].value;
87+
ViewPort.bars[i].value = leftArray[l].value;
88+
ViewPort.bars[i].panel.setBounds(0,Settings.allBarsPanelHeigth-ViewPort.bars[i].value,1000,ViewPort.bars[i].value);
89+
Thread.sleep(Settings.sortingDelay);
90+
i++;
91+
l++;
92+
} else {
93+
ar[i].value = rightArray[r].value;
94+
ViewPort.bars[i].value = rightArray[r].value;
95+
ViewPort.bars[i].panel.setBounds(0,Settings.allBarsPanelHeigth-ViewPort.bars[i].value,1000,ViewPort.bars[i].value);
96+
Thread.sleep(Settings.sortingDelay);
97+
i++;
98+
r++;
99+
}
100+
}
101+
}
102+
103+
while(l < leftSize) {
104+
ar[i].value = leftArray[l].value;
105+
ViewPort.bars[i].value = leftArray[l].value;
106+
ViewPort.bars[i].panel.setBounds(0,Settings.allBarsPanelHeigth-ViewPort.bars[i].value,1000,ViewPort.bars[i].value);
107+
Thread.sleep(Settings.sortingDelay);
108+
i++;
109+
l++;
110+
}
111+
while(r < rightSize) {
112+
ar[i].value = rightArray[r].value;
113+
ViewPort.bars[i].value = rightArray[r].value;
114+
ViewPort.bars[i].panel.setBounds(0,Settings.allBarsPanelHeigth-ViewPort.bars[i].value,1000,ViewPort.bars[i].value);
115+
Thread.sleep(Settings.sortingDelay);
116+
i++;
117+
r++;
118+
}
119+
}
120+
}

‎src/main/java/Algorithms/QuickSort.java‎

Lines changed: 64 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,64 @@
1+
package main.java.Algorithms;
2+
3+
import javax.swing.SwingWorker;
4+
import main.java.Bar;
5+
import main.java.Settings;
6+
import main.java.SortingAlgorithm;
7+
import main.java.SortingOrder;
8+
import main.java.FrameComponents.ViewPort;
9+
10+
public class QuickSort extends SortingAlgorithm { //O(n log n), worst O(n^2);
11+
12+
Bar[] ar = getArray();
13+
14+
15+
public QuickSort(Bar[] in) {
16+
super(in);
17+
}
18+
19+
@Override
20+
public void sort(SortingOrder so) {
21+
SwingWorker<Void, String> Worker = new SwingWorker<Void, String>(){
22+
23+
@Override
24+
protected Void doInBackground() throws Exception {
25+
quickSort(ar, 0, ar.length-1, so);
26+
return null;
27+
}
28+
};
29+
Worker.execute();
30+
}
31+
32+
void quickSort(Bar[] ar, int start, int end, SortingOrder so) throws Exception{
33+
if(end <= start) return;
34+
35+
int pivot = partition(ar, start, end, so);
36+
quickSort(ar, start, pivot -1, so);
37+
quickSort(ar, pivot +1, end, so);
38+
}
39+
40+
int partition(Bar[] ar, int start, int end, SortingOrder so) throws Exception{
41+
int pivot = ar[end].value;
42+
int i = start -1;
43+
44+
for(int j = start; j < end; j++) {
45+
if(so == SortingOrder.LtoH) {
46+
if(ar[j].value < pivot) {
47+
i++;
48+
swapBars(ViewPort.bars[i], ViewPort.bars[j]);
49+
Thread.sleep(Settings.sortingDelay);
50+
}
51+
} else {
52+
if(ar[j].value > pivot) {
53+
i++;
54+
swapBars(ViewPort.bars[i], ViewPort.bars[j]);
55+
Thread.sleep(Settings.sortingDelay);
56+
}
57+
}
58+
}
59+
i++;
60+
swapBars(ViewPort.bars[i], ViewPort.bars[end]);
61+
Thread.sleep(Settings.sortingDelay);
62+
return i;
63+
}
64+
}

0 commit comments

Comments
 (0)