Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit ae6382e

Browse files
author
javiluli
committed
Agrego 6 nuevos algoritmos sort: Binary insertion, bogo, bucket, gravity, intro y iterative merge; y actualizo el README
1 parent c1a3509 commit ae6382e

File tree

8 files changed

+487
-49
lines changed

8 files changed

+487
-49
lines changed
Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
package Ordenar.Algoritmos;
2+
3+
import java.util.Arrays;
4+
5+
import Ordenar.AdicionalesSorts;
6+
import Ordenar.ISort;
7+
import Principal.DibujarGraficos;
8+
import Principal.MainAplicacion;
9+
10+
public class BinaryInsertion extends AdicionalesSorts implements ISort {
11+
12+
public BinaryInsertion(MainAplicacion mainApp, int[] array) {
13+
this.mainApp = mainApp;
14+
sort(array);
15+
}
16+
17+
@Override
18+
public void sort(int[] array) {
19+
setInicio(System.currentTimeMillis());
20+
mainApp.updateAnimaciones();
21+
22+
for (int i = 1; i < array.length; i++) {
23+
int x = array[i];
24+
int j = Math.abs(Arrays.binarySearch(array, 0, i, x) + 1);
25+
System.arraycopy(array, j, array, j + 1, i - j);
26+
array[j] = x;
27+
mainApp.updateAnimaciones();
28+
}
29+
DibujarGraficos.finSort = true;
30+
}
31+
}

‎src/Ordenar/Algoritmos/Bogo.java

Lines changed: 42 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
1+
package Ordenar.Algoritmos;
2+
3+
import Ordenar.AdicionalesSorts;
4+
import Ordenar.ISort;
5+
import Principal.MainAplicacion;
6+
7+
public class Bogo extends AdicionalesSorts implements ISort {
8+
9+
public Bogo(MainAplicacion mainApp, int[] array) {
10+
this.mainApp = mainApp;
11+
sort(array);
12+
}
13+
14+
@Override
15+
public void sort(int[] array) {
16+
setInicio(System.currentTimeMillis());
17+
18+
while (isSorted(array) == false) {
19+
shuffle(array);
20+
mainApp.updateAnimaciones();
21+
}
22+
}
23+
24+
void shuffle(int[] array) {
25+
for (int i = 0; i < array.length; i++)
26+
swap(array, i, (int) (Math.random() * i));
27+
}
28+
29+
void swap(int[] array, int i, int j) {
30+
int temp = array[i];
31+
array[i] = array[j];
32+
array[j] = temp;
33+
}
34+
35+
boolean isSorted(int[] a) {
36+
for (int i = 1; i < a.length; i++)
37+
if (a[i] < a[i - 1])
38+
return false;
39+
return true;
40+
}
41+
42+
}

‎src/Ordenar/Algoritmos/BucketSort.java

Lines changed: 51 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,51 @@
1+
package Ordenar.Algoritmos;
2+
3+
//Bucket sort in Java
4+
5+
import java.util.ArrayList;
6+
import java.util.Collections;
7+
8+
import Ordenar.AdicionalesSorts;
9+
import Ordenar.ISort;
10+
import Principal.DibujarGraficos;
11+
import Principal.MainAplicacion;
12+
13+
public class BucketSort extends AdicionalesSorts implements ISort {
14+
15+
public BucketSort(MainAplicacion mainApp, int[] array) {
16+
this.mainApp = mainApp;
17+
sort(array);
18+
}
19+
20+
@Override
21+
public void sort(int[] array) {
22+
int len = array.length;
23+
setInicio(System.currentTimeMillis());
24+
if (len <= 0)
25+
return;
26+
27+
@SuppressWarnings("unchecked")
28+
ArrayList<Integer>[] bucket = new ArrayList[len];
29+
30+
for (int i = 0; i < len; i++)
31+
bucket[i] = new ArrayList<Integer>();
32+
33+
for (int i = 0; i < len; i++) {
34+
int bucketIndex = array[i];
35+
bucket[bucketIndex].add(array[i]);
36+
}
37+
38+
for (int i = 0; i < len; i++) {
39+
Collections.sort((bucket[i]));
40+
}
41+
42+
int index = 0;
43+
for (int i = 0; i < len; i++) {
44+
for (int j = 0, size = bucket[i].size(); j < size; j++) {
45+
array[index++] = bucket[i].get(j);
46+
}
47+
mainApp.updateAnimaciones();
48+
}
49+
DibujarGraficos.finSort = true;
50+
}
51+
}

‎src/Ordenar/Algoritmos/Gravity.java

Lines changed: 61 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,61 @@
1+
package Ordenar.Algoritmos;
2+
3+
import Ordenar.AdicionalesSorts;
4+
import Ordenar.ISort;
5+
import Principal.DibujarGraficos;
6+
import Principal.MainAplicacion;
7+
8+
public class Gravity extends AdicionalesSorts implements ISort {
9+
10+
public Gravity(MainAplicacion mainApp, int[] array) {
11+
this.mainApp = mainApp;
12+
sort(array);
13+
}
14+
15+
// @Override
16+
public void sort(int[] array) {
17+
setInicio(System.currentTimeMillis());
18+
19+
int max = max(array);
20+
int[][] abacus = new int[array.length][max];
21+
for (int i = 0; i < array.length; i++) {
22+
for (int j = 0; j < array[i]; j++)
23+
abacus[i][abacus[0].length - j - 1] = 1;
24+
}
25+
26+
// apply gravity
27+
for (int i = 0; i < abacus[0].length; i++) {
28+
for (int j = 0; j < abacus.length; j++) {
29+
if (abacus[j][i] == 1) {
30+
int droppos = j;
31+
while (droppos + 1 < abacus.length && abacus[droppos][i] == 1)
32+
droppos++;
33+
if (abacus[droppos][i] == 0) {
34+
abacus[j][i] = 0;
35+
abacus[droppos][i] = 1;
36+
accesoArray += 2;
37+
}
38+
}
39+
}
40+
41+
int count = 0;
42+
for (int x = 0; x < abacus.length; x++) {
43+
count = 0;
44+
for (int y = 0; y < abacus[0].length; y++)
45+
count += abacus[x][y];
46+
array[x] = count;
47+
}
48+
mainApp.updateAnimaciones();
49+
}
50+
DibujarGraficos.finSort = true;
51+
}
52+
53+
public int max(int[] array) {
54+
int a = 0;
55+
for (int i = 0; i < array.length; i++) {
56+
if (array[i] > a)
57+
a = array[i];
58+
}
59+
return a;
60+
}
61+
}

‎src/Ordenar/Algoritmos/Introsort.java

Lines changed: 127 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,127 @@
1+
package Ordenar.Algoritmos;
2+
3+
import Ordenar.AdicionalesSorts;
4+
import Ordenar.ISort;
5+
import Principal.DibujarGraficos;
6+
import Principal.MainAplicacion;
7+
8+
public class Introsort extends AdicionalesSorts implements ISort {
9+
10+
public Introsort(MainAplicacion mainApp, int[] array) {
11+
this.mainApp = mainApp;
12+
sort(array);
13+
}
14+
15+
@Override
16+
public void sort(int[] array) {
17+
setInicio(System.currentTimeMillis());
18+
sortData(array.length, array);
19+
DibujarGraficos.finSort = true;
20+
}
21+
22+
private void swap(int i, int j, int[] array) {
23+
int temp = array[i];
24+
array[i] = array[j];
25+
array[j] = temp;
26+
mainApp.updateAnimaciones();
27+
}
28+
29+
private void maxHeap(int i, int heapN, int begin, int[] array) {
30+
int temp = array[begin + i - 1];
31+
int child;
32+
33+
while (i <= heapN / 2) {
34+
child = 2 * i;
35+
if (child < heapN && array[begin + child - 1] < array[begin + child])
36+
child++;
37+
if (temp >= array[begin + child - 1])
38+
break;
39+
array[begin + i - 1] = array[begin + child - 1];
40+
i = child;
41+
}
42+
array[begin + i - 1] = temp;
43+
}
44+
45+
private void heapify(int begin, int end, int heapN, int[] array) {
46+
for (int i = (heapN) / 2; i >= 1; i--)
47+
maxHeap(i, heapN, begin, array);
48+
49+
}
50+
51+
private void heapSort(int begin, int end, int[] array) {
52+
int heapN = end - begin;
53+
this.heapify(begin, end, heapN, array);
54+
55+
for (int i = heapN; i >= 1; i--) {
56+
swap(begin, begin + i, array);
57+
maxHeap(1, i, begin, array);
58+
}
59+
}
60+
61+
private void insertionSort(int left, int right, int[] array) {
62+
63+
for (int i = left; i <= right; i++) {
64+
int key = array[i];
65+
int j = i;
66+
67+
while (j > left && array[j - 1] > key) {
68+
array[j] = array[j - 1];
69+
j--;
70+
}
71+
mainApp.updateAnimaciones();
72+
array[j] = key;
73+
}
74+
}
75+
76+
private int findPivot(int a1, int b1, int c1, int[] array) {
77+
int max = Math.max(Math.max(array[a1], array[b1]), array[c1]);
78+
int min = Math.min(Math.min(array[a1], array[b1]), array[c1]);
79+
int median = max ^ min ^ array[a1] ^ array[b1] ^ array[c1];
80+
if (median == array[a1])
81+
return a1;
82+
if (median == array[b1])
83+
return b1;
84+
return c1;
85+
}
86+
87+
private int partition(int low, int high, int[] array) {
88+
int pivot = array[high];
89+
int i = (low - 1);
90+
for (int j = low; j <= high - 1; j++) {
91+
if (array[j] <= pivot) {
92+
i++;
93+
swap(i, j, array);
94+
}
95+
}
96+
swap(i + 1, high, array);
97+
mainApp.updateAnimaciones();
98+
return (i + 1);
99+
}
100+
101+
private void sortDataUtil(int begin, int end, int depthLimit, int[] array) {
102+
if (end - begin > 16) {
103+
if (depthLimit == 0) {
104+
this.heapSort(begin, end, array);
105+
return;
106+
}
107+
108+
depthLimit = depthLimit - 1;
109+
int pivot = findPivot(begin, begin + ((end - begin) / 2) + 1, end, array);
110+
swap(pivot, end, array);
111+
112+
int p = partition(begin, end, array);
113+
114+
sortDataUtil(begin, p - 1, depthLimit, array);
115+
sortDataUtil(p + 1, end, depthLimit, array);
116+
}
117+
118+
else {
119+
insertionSort(begin, end, array);
120+
}
121+
}
122+
123+
private void sortData(int len, int[] array) {
124+
int depthLimit = (int) (2 * Math.floor(Math.log(len) / Math.log(2)));
125+
this.sortDataUtil(0, len - 1, depthLimit, array);
126+
}
127+
}
Lines changed: 70 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,70 @@
1+
package Ordenar.Algoritmos;
2+
3+
import Ordenar.AdicionalesSorts;
4+
import Ordenar.ISort;
5+
import Principal.DibujarGraficos;
6+
import Principal.MainAplicacion;
7+
8+
public class IterativeMerge extends AdicionalesSorts implements ISort {
9+
10+
public IterativeMerge(MainAplicacion mainApp, int[] array) {
11+
this.mainApp = mainApp;
12+
sort(array);
13+
}
14+
15+
@Override
16+
public void sort(int[] array) {
17+
setInicio(System.currentTimeMillis());
18+
int curr_size;
19+
int left_start;
20+
21+
for (curr_size = 1; curr_size <= array.length - 1; curr_size = 2 * curr_size) {
22+
for (left_start = 0; left_start < array.length - 1; left_start += 2 * curr_size) {
23+
int mid = left_start + curr_size - 1;
24+
int right_end = Math.min(left_start + 2 * curr_size - 1, array.length - 1);
25+
merge(array, left_start, mid, right_end);
26+
}
27+
}
28+
DibujarGraficos.finSort = true;
29+
}
30+
31+
void merge(int array[], int izq, int mit, int der) {
32+
int i, j, k;
33+
int n1 = mit - izq + 1;
34+
int n2 = der - mit;
35+
36+
int L[] = new int[n1];
37+
int R[] = new int[n2];
38+
39+
for (i = 0; i < n1; i++)
40+
L[i] = array[izq + i];
41+
for (j = 0; j < n2; j++)
42+
R[j] = array[mit + 1 + j];
43+
44+
i = 0;
45+
j = 0;
46+
k = izq;
47+
while (i < n1 && j < n2) {
48+
if (L[i] <= R[j]) {
49+
array[k] = L[i];
50+
i++;
51+
} else {
52+
array[k] = R[j];
53+
j++;
54+
}
55+
k++;
56+
mainApp.updateAnimaciones();
57+
}
58+
59+
while (i < n1) {
60+
array[k] = L[i];
61+
i++;
62+
k++;
63+
}
64+
while (j < n2) {
65+
array[k] = R[j];
66+
j++;
67+
k++;
68+
}
69+
}
70+
}

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /