Foro de elhacker.net

Programación => Java => Mensaje iniciado por: S_Code en 26 Mayo 2016, 11:33 am


Título: Problema con Pila (Stack), Hilos (Thread) y Lista números (Array)
Publicado por: S_Code en 26 Mayo 2016, 11:33 am
Buenos días.

Tengo un problema con un ejercicio y no se como solucionarlo.
El problema es que el código hace cada vez una cosa diferente:

- Se queda colapsado
- Se para y no realiza bien todo lo que tiene que hacer
- Da un error del tipo: ArrayOutIndexException
- Funciona correctamente

Dejo el código a ver si alguien puede ayudarme:

Clase principal

Código
  1. package quicksort;
  2.  
  3. import java.util.Stack;
  4. import java.util.Arrays;
  5.  
  6. public class QuicksortTarea {
  7. 	static Stack<int[]> pila = new Stack<int[]>();
  8. 	static int[] numeros = { 11, 25, 3, 9, 4 };
  9.  
  10. 	public static void main(String[] args) {
  11. 		System.out.println("Array de números sin ordenar");
  12. 		imprimirArrayNumeros(numeros);
  13. 		controlPilas();
  14. 		// Mostramos el array ordenado
  15. 		System.out.println("\nArray de números ordenados");
  16. 		imprimirArrayNumeros(numeros);
  17. 	}
  18.  
  19. 	// Método que muestra el array de números
  20. 	public static void imprimirArrayNumeros(int numeros[]) {
  21. 		for (int contador = 0; contador < numeros.length; contador++) {
  22. 			System.out.print(numeros[contador] + " ");
  23. 		}
  24. 	}
  25. 	public synchronized static void controlPilas() {
  26. 		//Introducimos la primera tarea en la pila
  27. 		int[] paso1 = new int[3];
  28. 		paso1 [0] = 0;
  29. 		paso1 [1] = numeros.length-1;
  30. 		//Indica si tiene thread 0 - NO / 1 - SI
  31. 		paso1 [2] = 0;
  32. 		pila.add(paso1);
  33. 		while (!pila.isEmpty()) {
  34. 			while (pila.get(pila.size()-1)[2] == 0) {
  35. 				ThreadTarea tarea = new ThreadTarea(pila, numeros, pila.get(pila.size()-1)[0], pila.get(pila.size()-1)[1]);
  36. 				tarea.start();
  37. 				pila.get(pila.size()-1)[2] = 1;
  38. 			}
  39. 		}
  40. 	}
  41. }

Clase Thread

Código
  1. package quicksort;
  2.  
  3. import java.util.Arrays;
  4. import java.util.Stack;
  5.  
  6. public class ThreadTarea extends Thread {
  7. 	Stack<int[]> pila; 
  8. 	int[] array;
  9. 	int izquierda;
  10. 	int derecha;
  11.  
  12. 	public ThreadTarea(Stack<int[]> pila, int[] array, int izquierda, int derecha) {
  13. 		this.pila = pila;
  14. 		this.array = array;
  15. 		this.izquierda = izquierda;
  16. 		this.derecha = derecha;	
  17. 	}
  18.  
  19. 	//Stack<int[]> pila, int[] array
  20. 	public void run() {
  21. 		//Guardamos los primeros valores de la pila
  22. 		int min =  pila.get(pila.size()-1)[0];
  23. 		int max =  pila.get(pila.size()-1)[1];
  24. 		//Usamos como pivote el valor de la izquierda
  25. 		int pivote = array[izquierda];
  26. 		System.out.println("\n El pivote es : " + pivote);
  27. 		//Creamos un boolean para comprobar el lado del array en el que estamos, siendo lado izquierdo = true y lado derecho = false
  28. 		boolean lado = false;
  29. 		while (izquierda < derecha) {
  30. 			if (lado == true) {
  31. 				if (array[izquierda] <= pivote) {
  32. 					izquierda++;
  33. 				}
  34. 				else {
  35. 					array[derecha] = array[izquierda];
  36. 					derecha--;
  37. 					lado = false;
  38. 				}
  39. 			}
  40. 			else {
  41. 				if (array[derecha] > pivote) {
  42. 					derecha--;
  43. 				}
  44. 				else {
  45. 					array[izquierda] = array[derecha];
  46. 					izquierda++;
  47. 					lado = true;
  48. 				}
  49. 			}
  50. 		}
  51. 		//Cambiamos el pivote de lado
  52. 		array[derecha] = pivote;
  53. 		// Comprobamos si necesitamos añadir nuevas tareas a la pila
  54. 		if (izquierda > min) {
  55. 			int[] paso2 = new int[3];
  56. 			paso2 [0] = min;
  57. 			paso2 [1] = izquierda-1;
  58. 			paso2 [2] = 0;
  59. 			pila.add(paso2);
  60. 		}
  61. 		if (derecha < max-1) {
  62. 			int[] paso3 = new int[3];
  63. 			paso3 [0] = derecha+1;
  64. 			paso3 [1] = max;
  65. 			paso3 [2] = 0;
  66. 			pila.add(paso3);
  67. 		}
  68. 		//Eliminamos la tarea de la pila porque ya se ha utilizado
  69. 		pila.remove(pila.size()-1);
  70. 	}
  71. }

Gracias de antemano.

Título: Re: Problema con Pila (Stack), Hilos (Thread) y Lista números (Array)
Publicado por: S_Code en 27 Mayo 2016, 12:19 pm
Buenos días, de nuevo.

Al final he conseguido solucionar los problemas, era un problema de sincronización de la pila. Pero ahora tengo otro:

- El programa funciona perfectamente con el código que aquí pongo, el problema viene cuando quiero darle un tamaño determinado al array o incluso poner otros números, no llega a salir del bucle de la clase principal con lo cual no muestra el mensaje del array ordenado.

Pongo aquí el código actual a ver si alguien consigue decirme porque no llega a finalizar el programa. Gracias de antemano.

Clase principal
Código
  1. package quicksort;
  2.  
  3. import java.util.Stack;
  4. import java.util.Arrays;
  5.  
  6. public class QuicksortTarea {
  7. 	static Pila pila = new Pila ();
  8. 	static int[] numeros = {11, 2, 3, 8, 4, 1, 10};
  9. //	static int[] numeros = new int [8];
  10. 	static ThreadTarea tarea;
  11. 	public static void main(String[] args) throws InterruptedException {
  12. //		rellenarArray(numeros);
  13. 		System.out.println("Array de números sin ordenar : ");
  14. 		imprimirArrayNumeros(numeros);
  15. 		controlPilas();
  16. 		//Mostramos el array ordenado
  17. 		System.out.println("\nArray de números ordenados : ");
  18. 		imprimirArrayNumeros(numeros);
  19. 	}
  20.  
  21. 	// Método que rellena el array con números aleatorios
  22. 	public static void rellenarArray(int numeros[]) {
  23. 		for (int contador = 0; contador < numeros.length; contador++) {
  24. 			numeros[contador] = numeroAleatorio();
  25. 		}
  26. 	}
  27.  
  28. 	//Método que devuelve un número aleatorio
  29. 	public static int numeroAleatorio() {
  30. 		int num = (int) (Math.random() * 10);
  31. 		return num;
  32. 	}
  33.  
  34. 	//Método que muestra el array de números
  35. 	public static void imprimirArrayNumeros(int numeros[]) {
  36. 		for (int contador = 0; contador < numeros.length; contador++) {
  37. 			System.out.print(numeros[contador] + " ");
  38. 		}
  39. 	}
  40. 	//Método control tarea pilas
  41. 	public synchronized static void controlPilas() throws InterruptedException {
  42. 		//Introducimos la primera tarea en la pila
  43. 		int[] paso1 = new int[3];
  44. 		paso1 [0] = 0;
  45. 		paso1 [1] = numeros.length-1;
  46. 		//Indica si tiene thread 0 - NO / 1 - SI
  47. 		paso1 [2] = 0;
  48. 		//Añadimos el array de la tarea a la pila
  49. 		pila.masTarea(paso1);
  50. 		//Mientras la pila este llena
  51. 		while (pila.llena() == false) {
  52. 			//Si la posición donde se indica el thread es 0, lo creamoos
  53. 			while (pila.dimo()[2] == 0) {
  54. 				tarea = new ThreadTarea(pila, numeros);
  55. 				tarea.start();
  56. 				//Cambiamos el valor
  57. 				pila.dimo()[2] = 1;
  58. 			}
  59. 			tarea.sleep(200);
  60. 		}
  61. 	}
  62. }


Clase Thread
Código
  1. package quicksort;
  2.  
  3. import java.util.Arrays;
  4. import java.util.Stack;
  5.  
  6. public class ThreadTarea extends Thread {
  7. 	//Pila y array
  8. 	static Pila pila = new Pila (); 
  9. 	int[] array;
  10. 	/**
  11. 	 * Constructor del thread
  12. 	 */
  13. 	public ThreadTarea(Pila pila, int[] array) {
  14. 		this.pila = pila;
  15. 		this.array = array;
  16. 	}
  17.     /**
  18.      * Método del run del thread
  19.      */
  20.     @Override
  21. 	public void run() {
  22. 		//Asignamos los valores de inicio y final de la pila
  23. 		int izquierda = pila.dimo()[0];
  24. 		int derecha =  pila.dimo()[1];
  25. 		//Guardamos los primeros valores de la pila en otras variables para despues
  26. 		int min =  pila.dimo()[0];
  27. 		int max =  pila.dimo()[1];
  28. 		//Usamos como pivote el valor de la izquierda
  29. 		int pivote = array[izquierda];
  30. 		//Boolean para controlar los lados que colocamos
  31. 		boolean lado = false;
  32. 		//Mientras izquierda sea menor o igual que derecha
  33. 		while (izquierda != derecha) {
  34. 			//Lado izquierdo
  35. 			if (lado) {
  36. 				if (array[izquierda] <= pivote) {
  37. 					izquierda++;
  38. 				}
  39. 				else {
  40. 					array[derecha] = array[izquierda];
  41. 					derecha--;
  42. 					lado = false;
  43. 				}
  44. 			}
  45. 			//Lado derecho
  46. 			else {
  47. 				if (array[derecha] > pivote) {
  48. 					derecha--;
  49. 				}
  50. 				else {
  51. 					array[izquierda] = array[derecha];
  52. 					izquierda++;
  53. 					lado = true;
  54. 				}
  55. 			}
  56. 		}
  57. 		//Intecambiamos los números
  58. 		array[derecha] = pivote;
  59. 		//Comprobamos si necesitamos añadir nuevas tareas a la pila
  60. 		if (izquierda > min) {
  61. 			int[] paso2 = new int[3];
  62. 			paso2 [0] = min;
  63. 			paso2 [1] = izquierda-1;
  64. 			paso2 [2] = 0;
  65. 			pila.masTarea(paso2);
  66. 			System.out.println(" SEGUNDA TAREA ");
  67. 		}
  68. 		if (derecha < max-1) {
  69. 			int[] paso3 = new int[3];
  70. 			paso3 [0] = derecha+1;
  71. 			paso3 [1] = max;
  72. 			paso3 [2] = 0;
  73. 			pila.masTarea(paso3);
  74. 			System.out.println(" TERCERA TAREA ");
  75. 		}
  76. 		//Eliminamos la tarea de la pila porque ya se ha utilizado
  77. 		pila.quitarTarea(pila.size());
  78. 	}
  79. }

Clase Pila

Código
  1. package quicksort;
  2.  
  3. import java.util.Stack;
  4.  
  5. public class Pila {
  6.  
  7. 	static Stack<int[]> pila = new Stack <int[]>();
  8. 	static int dim = pila.size(); 
  9.  
  10. 	public Pila() {
  11. 		super();
  12. 	}
  13.  
  14. 	public synchronized static int[] dimo() {
  15. 		return pila.get(pila.size()-1);
  16. 	}
  17. 	public synchronized void masTarea (int [] tarea) {
  18. 		pila.add(tarea);
  19. 	}
  20. 	public synchronized void quitarTarea (int tam) {
  21. 		if (pila.size() >= 1) {
  22. 			pila.remove(tam);
  23. 		}
  24. 		else {
  25. 			return;
  26. 		}
  27. 	}
  28. 	public synchronized boolean llena (){
  29. 		if (pila.isEmpty()) {
  30. 			return true;
  31. 		}
  32. 		else {
  33. 			return false;
  34. 		}
  35. 	}
  36. 	public synchronized int size() {
  37. 		if (pila.size() >= 1) {
  38. 			return dim;
  39. 		}
  40. 		else {
  41. 			return 0;
  42. 		}
  43. 	}
  44. 	public synchronized int[] get(int i) {
  45. 		return null;
  46. 	}
  47.  
  48. }
  49.  


Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines