Java BlueJ Bubblesort

Question

J'ai une question concernant mon projet Java. Dans School, nous avons commencé à écrire une méthode bubbleort, qui est censée trier une liste d'entiers, puis les trier graphiquement. Cependant, mon problème est que nous avons dû le finir à la maison, et je semble être coincé avec une petite chose.

Ce code est toute ma Bubblesort classe:

import java.util.Random; 
/** 
* Write a description of class Bubblesort here. 
* 
* @author Aaron Zwickenpflug 
* @version 30.01.2017 
*/ 
public class Bubblesort { 
    private Random random; 
    private int maxSquare; 
    private int maxRandom; 
    private int[] x; 
    private Square[] square; 

    public Bubblesort() { 
     this.random = new Random(); 

     this.maxSquare = 100; 
     this.maxRandom = 200; 

     this.x = new int[this.maxSquare]; 
     this.square = new Square[this.maxSquare]; 

     for (int i = 0; i < this.maxSquare; i++) { 
      this.square[i] = new Square(i, x[i]); 
      this.x[i] = random.nextInt(maxRandom); 
      this.square[i].changeY(x[i]); 
      // System.out.println(this.x[i]); 
     } 
    } 

    public void redraw() { 
     for (int i = 0; i < this.maxSquare - 1; i++) { 
      this.square[i + 1].changeY(this.x[i]); 
     } 
    } 

    public void sort_bubble() { 
     int m; 
     for (int i = 1; i < 100; i++) { 
      for (int y = 0; y < this.maxSquare - i; y++) { 
       if (this.x[y] > this.x[y + 1]) { 
        m = this.x[y]; 
        this.x[y] = this.x[y + 1]; 
        this.x[y + 1] = m; 
        this.square[y + 1].changeY(this.x[i + 1]); 
       } 
      } 
     } 
    } 

} 

Voici la classe Square:

import java.awt.*; 

/** 
* A square that can be manipulated and that draws itself on a canvas. 
* 
* @author Michael Kölling and David J. Barnes 
* @version 2016.02.29 
*/ 

public class Square { 
    private int xSize; 
    private int ySize; 
    private int xPosition; 
    private int yPosition; 
    private String color; 
    private boolean isVisible; 

    /** 
    * Create a new square at default position with default color. 
    */ 
    public Square(int xPos, int height) { 
     xSize = 9; 
     ySize = height; 
     xPosition = xPos * 10; 
     yPosition = 1; 
     color = "green"; 
     isVisible = false; 
    } 

    public void changeY(int x) { 
     this.ySize = x; 
     makeVisible(); 
    } 

    /** 
    * Make this square visible. If it was already visible, do nothing. 
    */ 
    public void makeVisible() { 
     isVisible = true; 
     draw(); 
    } 

    /** 
    * Make this square invisible. If it was already invisible, do nothing. 
    */ 
    public void makeInvisible() { 
     erase(); 
     isVisible = false; 
    } 

    /** 
    * Move the square a few pixels to the right. 
    */ 
    public void moveRight() { 
     moveHorizontal(20); 
    } 

    /** 
    * Move the square a few pixels to the left. 
    */ 
    public void moveLeft() { 
     moveHorizontal(-20); 
    } 

    /** 
    * Move the square a few pixels up. 
    */ 
    public void moveUp() { 
     moveVertical(-20); 
    } 

    /** 
    * Move the square a few pixels down. 
    */ 
    public void moveDown() { 
     moveVertical(20); 
    } 

    /** 
    * Move the square horizontally by 'distance' pixels. 
    */ 
    public void moveHorizontal(int distance) { 
     erase(); 
     xPosition += distance; 
     draw(); 
    } 

    /** 
    * Move the square vertically by 'distance' pixels. 
    */ 
    public void moveVertical(int distance) { 
     erase(); 
     yPosition += distance; 
     draw(); 
    } 

    /** 
    * Slowly move the square horizontally by 'distance' pixels. 
    */ 
    public void slowMoveHorizontal(int distance) { 
     int delta; 

     if(distance < 0) { 
      delta = -1; 
      distance = -distance; 
     } else { 
      delta = 1; 
     } 

     for(int i = 0; i < distance; i++) { 
      xPosition += delta; 
      draw(); 
     } 
    } 

    /** 
    * Slowly move the square vertically by 'distance' pixels. 
    */ 
    public void slowMoveVertical(int distance) { 
     int delta; 

     if(distance < 0) { 
      delta = -1; 
      distance = -distance; 
     } else { 
      delta = 1; 
     } 

     for(int i = 0; i < distance; i++) { 
      yPosition += delta; 
      draw(); 
     } 
    } 

    /** 
    * Change the size to the new size (in pixels). Size must be >= 0. 
    */ 
    public void changeSize(int newSize) { 
     erase(); 
     xSize = newSize; 
     ySize = newSize; 
     draw(); 
    } 

    /** 
    * Change the color. Valid colors are "red", "yellow", "blue", "green", 
    * "magenta" and "black". 
    */ 
    public void changeColor(String newColor) { 
     color = newColor; 
     draw(); 
    } 

    /** 
    * Draw the square with current specifications on screen. 
    */ 
    private void draw() { 
     if(isVisible) { 
      Canvas canvas = Canvas.getCanvas(); 
      canvas.draw(this, color, 
         new Rectangle(xPosition, yPosition, xSize, ySize)); 
      canvas.wait(10); 
     } 
    } 

    /** 
    * Erase the square on screen. 
    */ 
    private void erase() { 
     if(isVisible) { 
      Canvas canvas = Canvas.getCanvas(); 
      canvas.erase(this); 
     } 
    } 
} 

Maintenant, le problème se trouve dans la dernière ligne:

this.square[y + 1].changeY(this.x[i + 1]); 

Il devrait normalement (quand je cours le programme) Changer la coordonnée y entre 2 squar es, et «trier». Bien que cela ne fait que gâcher les graphiques, et les carrés commencent à changer à des valeurs étranges. J'ai inspecté la liste qui doit être triée, et cela fonctionne plutôt bien.

Voici comment les graphiques ne ressemblent:

J'espère que quelqu'un peut me aider avec mon problème. Merci à l'avance, A

Answer 1

Je pris un certain temps pour regarder votre code, j'aurais reconnu le problème plus tôt, mais la classe Canvas que vous utilisez me secouèrent. Donc, je réécris votre programme en utilisant des composants Java Swing au lieu de composants juste AWT, et après avoir corrigé une ligne et ajouté une ligne de code dans votre méthode sort_bubble(), je suis le résultat suivant:

Le problème a menti dans l'échange d'éléments dans votre méthode sort_bubble() ou échange plutôt les éléments dans votre tableau int sous-jacente mais pas la mise à jour du tableau Square correctement:

m = this.x[y]; 
this.x[y] = this.x[y + 1]; 
this.x[y + 1] = m; 
this.square[y + 1].changeY(this.x[i + 1]); 

au-dessus de vous échanger x[y] avec x[y + 1] mais pour une raison quelconque, vous mettez à jour square[y + 1] avec la valeur x[i + 1]. Vos mises à jour du tableau Square doivent refléter vos swaps sur le tableau sous-jacent int. Par conséquent, votre code d'échange et de mise à jour en sort_bubble() devrait ressembler à:

m = this.x[y]; 
this.x[y] = this.x[y + 1]; 
this.x[y + 1] = m; 

// reflect the above swaps when updating 'this.square' 
this.square[y].changeY(this.x[y]); 
this.square[y + 1].changeY(this.x[y + 1]); 

espoir cette réponse aide et désolé il a fallu un certain temps pour y répondre. Faites-moi savoir si vous avez d'autres questions concernant ce que j'ai mentionné dans cette réponse.