elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Usando Git para manipular el directorio de trabajo, el índice y commits (segunda parte)


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  Java
| | | |-+  Problema con Pila (Stack), Hilos (Thread) y Lista números (Array)
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Problema con Pila (Stack), Hilos (Thread) y Lista números (Array)  (Leído 1,977 veces)
S_Code

Desconectado Desconectado

Mensajes: 4


Ver Perfil
Problema con Pila (Stack), Hilos (Thread) y Lista números (Array)
« 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.


« Última modificación: 26 Mayo 2016, 11:51 am por S_Code » En línea

S_Code

Desconectado Desconectado

Mensajes: 4


Ver Perfil
Re: Problema con Pila (Stack), Hilos (Thread) y Lista números (Array)
« Respuesta #1 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.  


En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
[Solucionado]Duda funcionamiento Thread/Hilos
Java
NetJava 6 4,166 Último mensaje 25 Marzo 2011, 16:29 pm
por NetJava
Como se representa un array en la pila
ASM
leucocito 5 5,538 Último mensaje 22 Mayo 2011, 13:21 pm
por leucocito
Ayuda con la Pila (Stack)
ASM
isidora 6 4,941 Último mensaje 3 Diciembre 2011, 03:33 am
por Иōҳ
Duda con la pila (stack)
ASM
exploiterstack 5 3,559 Último mensaje 29 Mayo 2015, 15:15 pm
por cpu2
Respecto a la pila o memoria estatica..(o stack)
Programación C/C++
digimikeh 2 1,328 Último mensaje 4 Mayo 2019, 05:05 am
por digimikeh
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines