Java BlueJ Bubblesort

Question

我有一个关于我的Java项目的问题。在学校，我们开始编写一个冒泡排序方法，它应该对整数列表进行排序，然后以图形方式对它们进行排序。然而，我的问题是我们必须在家里完成它，而我似乎被一件小事卡住了。

这是我的Bubblesort类的全部代码：

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]);
                }
            }
        }
    }

}

下面是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);
        }
    }
}

现在，问题出在最后一行：

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

它通常(当我运行程序时)在两个正方形之间改变y坐标，并对其进行“排序”。虽然它只是弄乱了图形，并且正方形开始变成一些奇怪的值。我确实检查了需要排序的列表，它工作得很好。

图形的外观如下所示：

​

我希望有人能帮我解决我的问题。提前谢谢你，A

Answer 1

我花了一些时间看了你的代码，我应该早点发现这个问题，但是你使用的Canvas类把我弄糊涂了。因此，我使用Java Swing组件而不仅仅是AWT组件重写了您的程序，并且在sort_bubble()方法中更正了一行并添加了一行代码后，我得到了以下结果：

​

​

问题在于交换sort_bubble()方法中的元素，或者更确切地说，交换底层int数组中的元素，但随后没有正确更新Square数组：

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]);

上面你用x[y + 1]替换了x[y]，但是出于某种原因，你用x[i + 1]的值更新了square[y + 1]。您对Square阵列的更新应反映您在底层int阵列上的交换。因此，您在sort_bubble()中的交换和更新代码应该类似于：

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]);

希望这个答案能有所帮助，很抱歉花了一段时间才回复。如果你对我在这个答案中提到的内容有任何进一步的问题，请让我知道。