250 lines
6.9 KiB
Java
250 lines
6.9 KiB
Java
package cl.cromer.estructuras;
|
|
|
|
/**
|
|
* Crear una estructura de dato de tipo array.
|
|
* @author Chris Cromer
|
|
*/
|
|
public class Array {
|
|
/**
|
|
* El array.
|
|
*/
|
|
private String array[];
|
|
|
|
/**
|
|
* La cantidad de elementos en el array.
|
|
*/
|
|
private int size;
|
|
|
|
/**
|
|
* Si es de tipo ordenado o simple.
|
|
*/
|
|
private boolean ordered;
|
|
|
|
/**
|
|
* Crear el array con el tamaño pasador por argumento.
|
|
* @param temano int: El temaño del array a crear.
|
|
*/
|
|
public Array(int temano) {
|
|
this.array = new String[temano];
|
|
size = 0;
|
|
ordered = false;
|
|
}
|
|
|
|
/**
|
|
* Devolver la cantidad de elementos en el array.
|
|
* @return int: Devolver la cantidad de elementos en el array.
|
|
*/
|
|
public int size() {
|
|
return size;
|
|
}
|
|
|
|
/**
|
|
* Dovolver si el tipo es ordenado o no.
|
|
* @return boolean: Si el tipo de array es ordenado.
|
|
*/
|
|
public boolean isOrdered() {
|
|
return ordered;
|
|
}
|
|
|
|
/**
|
|
* Cambiar el tipo de array entre ordenado o simple.
|
|
* @param ordered boolean: Si es verdad, es de tipo ordenado, sino el tipo es simple.
|
|
*/
|
|
public void setOrdered(boolean ordered) {
|
|
this.ordered = ordered;
|
|
}
|
|
|
|
/**
|
|
* Insertar un valor al array.
|
|
* @param valor int: El valor a insertar.
|
|
* @return boolean: Verdad si fue exitoso, sino falso.
|
|
*/
|
|
public boolean insertar(int valor) {
|
|
for (int i = 0; i < array.length; i++) {
|
|
if (array[i] == null) {
|
|
array[i] = String.valueOf(valor);
|
|
size++;
|
|
return true;
|
|
}
|
|
else if (array[i].equals(String.valueOf(valor))) {
|
|
// Ya existe el valor en el array
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Eliminar un valor del array si existe.
|
|
* @param valor int: El valor a eliminar.
|
|
* @return boolean: Verdad si fue encontrado y borrado, sino falso.
|
|
*/
|
|
public boolean eliminar(int valor) {
|
|
boolean borrado = false;
|
|
for (int i = 0; i < array.length; i++) {
|
|
if (array[i] != null && array[i].equals(String.valueOf(valor))) {
|
|
// Eliminar el valor
|
|
array[i] = null;
|
|
borrado=true;
|
|
size--;
|
|
if (ordered) {
|
|
for (int j = i; j < array.length; j++) {
|
|
if (j != array.length - 1) {
|
|
// Correr la array hacia arriba
|
|
array[j] = array[j + 1];
|
|
}
|
|
}
|
|
array[array.length-1] = null;
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return borrado;
|
|
}
|
|
|
|
/**
|
|
* Buscar si existe un valor dentro el array.
|
|
* @param valor int: Valor a buscar.
|
|
* @return int: Devuelve el indice donde fue encontrado, o -1 si no fue encontrado.
|
|
*/
|
|
public int buscar(int valor) {
|
|
for (int i = 0; i < array.length; i++) {
|
|
if (array[i] != null && array[i].equals(String.valueOf(valor))) {
|
|
// Se encontró
|
|
return i;
|
|
}
|
|
}
|
|
// No se encontró
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Devolver el valor que está guardado en cada indice del array. Se usa para construir la grafica.
|
|
* @param indice int: El indice que desea ver.
|
|
* @return String: El valor que está en dicho indice.
|
|
*/
|
|
public String getIndice(int indice) {
|
|
if (indice >= 0 && indice < array.length) {
|
|
return array[indice];
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ordenar el array usando burbuja.
|
|
* @param paso boolean: Si es verdad, solo hago en paso del ordenamiento, sino ordenear todos los elementos.
|
|
* @return boolean: Verdad si algo cambió, sino falso.
|
|
*/
|
|
public boolean burbuja(boolean paso) {
|
|
boolean cambio = false;
|
|
|
|
for (int i = size() - 1; i > 1; i--) {
|
|
for (int j = 0; j < i; j++) {
|
|
if (Integer.valueOf(array[j]) > Integer.valueOf(array[j+1])) {
|
|
String temp = array[j];
|
|
array[j] = array[j+1];
|
|
array[j+1] = temp;
|
|
cambio = true;
|
|
if (paso) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return cambio;
|
|
}
|
|
|
|
/**
|
|
* Ordenar el array usando inserción.
|
|
* @param paso boolean: Si es verdad, solo hago en paso del ordenamiento, sino ordenear todos los elementos.
|
|
* @return boolean: Verdad si algo cambió, sino falso.
|
|
*/
|
|
public boolean insercion(boolean paso) {
|
|
boolean cambio = false;
|
|
|
|
for (int i = 1; i < size(); i++) {
|
|
String temp = array[i];
|
|
int j = i;
|
|
while (j > 0 && Integer.valueOf(array[j-1]) >= Integer.valueOf(temp)) {
|
|
array[j] = array[j-1];
|
|
--j;
|
|
cambio = true;
|
|
}
|
|
array[j] = temp;
|
|
if (paso && cambio) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return cambio;
|
|
}
|
|
|
|
/**
|
|
* Ordenar el array usando selección.
|
|
* @param paso boolean: Si es verdad, solo hago en paso del ordenamiento, sino ordenear todos los elementos.
|
|
* @return boolean: Verdad si algo cambió, sino falso.
|
|
*/
|
|
public boolean seleccion(boolean paso) {
|
|
boolean cambio = false;
|
|
|
|
for (int i = 0; i < size() - 1; i++) {
|
|
int minimo = i;
|
|
for (int j = i + 1; j < size(); j++) {
|
|
if (Integer.valueOf(array[j]) < Integer.valueOf(array[minimo])) {
|
|
minimo = j;
|
|
cambio = true;
|
|
}
|
|
}
|
|
String temp = array[i];
|
|
array[i] = array[minimo];
|
|
array[minimo] = temp;
|
|
if (paso && cambio) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return cambio;
|
|
}
|
|
|
|
/**
|
|
* Ordenar el array usando shell.
|
|
* @param paso boolean: Si es verdad, solo hago en paso del ordenamiento, sino ordenear todos los elementos.
|
|
* @return boolean: Verdad si algo cambió, sino falso.
|
|
*/
|
|
public boolean shell(boolean paso) {
|
|
boolean cambio = false;
|
|
|
|
int j, i;
|
|
String temp;
|
|
|
|
int h = 1;
|
|
while (h <= size() / 3) {
|
|
h = h * 3 + 1;
|
|
}
|
|
|
|
while (h > 0) {
|
|
for (i=h; i < size(); i++) {
|
|
temp = array[i];
|
|
j = i;
|
|
while (j > h-1 && Integer.valueOf(array[j-h]) >= Integer.valueOf(temp)) {
|
|
array[j] = array[j-h];
|
|
j -= h;
|
|
cambio = true;
|
|
}
|
|
array[j] = temp;
|
|
if (paso && cambio) {
|
|
return true;
|
|
}
|
|
}
|
|
h = (h-1) / 3;
|
|
}
|
|
|
|
return cambio;
|
|
}
|
|
}
|