Question

我正在尝试使用JavaFX库为快速排序算法的分区部分设置动画。我得到了该程序的所有图形部分，但我的步骤方法有问题。我的步骤方法中存在逻辑错误，我似乎无法弄清楚它是什么。每次单击步骤按钮时，步骤方法应该执行一步。

private void quickSort(int lowerIndex, int higherIndex) {

    int i = lowerIndex;
    int j = higherIndex;
    // calculate pivot number, I am taking pivot as middle index number
    int pivot = array[lowerIndex+(higherIndex-lowerIndex)/2];
    // Divide into two arrays
    while (i <= j) {
        /**
         * In each iteration, we will identify a number from left side which
         * is greater then the pivot value, and also we will identify a number
         * from right side which is less then the pivot value. Once the search
         * is done, then we exchange both numbers.
         */
        while (array[i] < pivot) {
            i++;
        }
        while (array[j] > pivot) {
            j--;
        }
        if (i <= j) {
            exchangeNumbers(i, j);
            //move index to next position on both sides
            i++;
            j--;
        }
    }
    // call quickSort() method recursively
    if (lowerIndex < j)
        quickSort(lowerIndex, j);
    if (i < higherIndex)
        quickSort(i, higherIndex);
}

上面的代码是快速排序算法的源代码，步骤方法应该只执行快速排序算法的一个步骤。我尝试在步骤方法中实现相同的逻辑，但我的逻辑是错误的。此计划的正确输出位于此链接http://www.cs.armstrong.edu/liang/animation/web/QuickSortPartition.html 以供参考。

以下是我正在使用的代码

 import java.util.Arrays;
 import javafx.application.Application;
 import javafx.geometry.Pos;
 import javafx.scene.Scene;
 import javafx.scene.control.Button;
 import javafx.scene.layout.BorderPane;
 import javafx.scene.layout.HBox;
 import javafx.scene.layout.Pane;
 import javafx.scene.paint.Color;
 import javafx.scene.shape.Line;
 import javafx.scene.shape.Rectangle;
 import javafx.scene.text.Text;
 import javafx.stage.Stage;

 public class AnimateQuickSort extends Application {
    public final static int ARRAY_SIZE = 20;
    private int[] array = new int[ARRAY_SIZE];
    private int leftP = 1;
    private int rightP = array.length - 1;
    private int pivot = 0;

public void start(Stage primaryStage) {
    AnimationPane pane = new AnimationPane();

    Button btStep = new Button("Step");
    Button btReset = new Button("Reset");

    HBox hBox = new HBox(5);
    hBox.getChildren().addAll(btStep, btReset);
    hBox.setAlignment(Pos.CENTER);

    BorderPane borderPane = new BorderPane();
    borderPane.setCenter(pane);
    borderPane.setBottom(hBox);

    // Create a scene and place it in the stage
    Scene scene = new Scene(borderPane, 700, 225);
    primaryStage.setTitle("QuickSort");
    primaryStage.setScene(scene);
    primaryStage.show();

    initializeArray();

    pane.repaint();

    btStep.setOnAction(e -> {
        if (step()) {
            pane.repaint();
        } else {
            pane.repaint();
        }
    });

    btReset.setOnAction(e -> {
        reset();
        pane.repaint();
    });
}

public static void main(String[] args) {
    launch(args);
}

public void initializeArray() {

    for (int i = 0; i < array.length; i++) {
        array[i] = (int) (Math.random() * 999 + 1);
    }

    // Arrays.sort(array);

}

public void reset() {
    leftP = 1;
    rightP = array.length - 1;
    pivot = 0;
    initializeArray();
}

public boolean step() {
    // quicksort(array);
    int begin = 0;
    int pivotVal = array[0];
    int array1;

    if (leftP <= rightP && array[leftP] <= pivotVal) {
        leftP++;
        array1 = array[leftP];
        array[leftP] = array[rightP];
        array[rightP] = array1;
    }

    if (rightP >= leftP && array[rightP] > pivotVal) {
        rightP--;
    }
    if (rightP > leftP) {
        if (rightP != begin) {
            array1 = array[rightP];
            array[rightP] = array[begin];
            array[begin] = array1;
        }
    }
    // Return the index of the pivot element.
    return true;
}

class AnimationPane extends Pane {
    private int startingX = 20;
    private int startingY = 20;
    private int boxWidth = 30;
    private int boxHeight = 20;

    protected void repaint() {
        this.getChildren().clear();

        int x = startingX + 10;
        int y = startingY + 40;

        // Display array
        x = startingX + 10;
        getChildren().add(new Text(x - 15, y + 55, "Array "));
        x += 20;
        getChildren().add(new Text(x + pivot * boxWidth, y + 120, "Pivot"));
        drawArrowLine(x + 15 + pivot * boxWidth, y + 100, x + 15 + pivot * boxWidth, y + 40 + boxHeight);

        getChildren().add(new Text(x - 14 + leftP * boxWidth, startingY, "Left Pointer"));
        drawArrowLine(x + 15 + leftP * boxWidth, startingY, x + 15 + leftP * boxWidth, y + 40);

        getChildren().add(new Text(x - 14 + rightP * boxWidth, startingY, "Right Pointer"));
        drawArrowLine(x + 15 + rightP * boxWidth, startingY, x + 15 + rightP * boxWidth, y + 40);

        for (int k = 0; k < array.length; k++) {
            Rectangle rectangle = new Rectangle(x, y + 40, boxWidth, boxHeight);
            rectangle.setFill(Color.WHITE);
            rectangle.setStroke(Color.BLACK);
            getChildren().add(rectangle);
            if (array[k] != 0) {
                getChildren().add(new Text(x + 5, y + 55, array[k] + ""));
            }
            x = x + boxWidth;
        }
    }

    public void drawArrowLine(double x1, double y1, double x2, double y2) {
        getChildren().add(new Line(x1, y1, x2, y2));

        // find slope of this line
        double slope = ((((double) y1) - (double) y2)) / (((double) x1) - (((double) x2)));

        double arctan = Math.atan(slope);

        // This will flip the arrow 45 off of a
        // perpendicular line at pt x2
        double set45 = 1.57 / 2;

        // arrows should always point towards i, not i+1
        if (x1 < x2) {
            // add 90 degrees to arrow lines
            set45 = -1.57 * 1.5;
        }

        // set length of arrows
        int arrlen = 15;

        // draw arrows on line
        getChildren().add(new Line(x2, y2, (x2 + (Math.cos(arctan + set45) * arrlen)),
                ((y2)) + (Math.sin(arctan + set45) * arrlen)));

        getChildren().add(new Line(x2, y2, (x2 + (Math.cos(arctan - set45) * arrlen)),
                ((y2)) + (Math.sin(arctan - set45) * arrlen)));
    }
}
 }

Answer 1

你不能在没有协同程序的情况下单步执行递归函数（Java中有多个协程库库，但大多数都调整JVM或字节码，所以不是真正标准的东西）。

你基本上有两个选择：

如果可以，则转换职责：代替动画调用QuickSort的单步，让QuickSort调用动画重绘。
或者，为了实现执行QuickSort单步操作的功能，您需要展开递归，这将要求您跟踪＆＃34;深度＆＃34;使用明确的from-to对堆栈。堆栈以＆＃34;整个数组开始＆＃34 ;;在函数的顶部，弹出一个状态并对该范围进行排序;当你想要递归时，你将较小的范围推到堆栈上;当堆栈为空时，你就完成了。

Answer 2

“hacky”解决方案

这需要访问com.sun.javafx.tk.Toolkit，这不是特别好的做法，因为它位于com.sun个包中（请参阅It is a bad practice to use Sun's proprietary Java classes?）。

但是，这允许您“暂停”从fxApplication线程调用的方法的执行，直到事件发生。

使用

Toolkit.getToolkit().enterNestedEventLoop(loopId);

“暂停”方法和

Toolkit.getToolkit().exitNestedEventLoop(loopId, value);

恢复方法。

loopId必须与Object相同。

enterNestedEventLoop返回传递给exitNestedEventLoop的值。

使用这些方法，您只需将动画添加到quicksort方法，并在步骤完成时“暂停”并从Button事件处理程序“恢复”执行。

清洁解决方案

您基本上将动画的每个状态保存到列表中，以便可以逐步执行：

更改您的AnimationPane以支持以下方法：

setUpperArrowPosition(int)，setPivotArrowPosition(int)和setLowerArrowPosition(int)分别改变上部，枢轴和下部箭头的位置。
swap(int, int)此方法交换数组的2个元素的可视化表示。

通过这种方式，您不仅可以更清洁地设计，而且还可以更轻松地将更改操作“保存”到List：

创建字段List<Comsumer<AnimationPane>> steps。此列表中的每个元素都会使用上面定义的新方法更改AnimationPane的状态，以表示每个步骤后的状态。在实际进行排序之前，您需要初始化AnimationPane。然后在排序期间，您只需将需要完成的所有更改作为Consumer添加到UI中，以便稍后执行，例如而不是

while (array[i] < pivot) {
    i++;
}

使用

while (array[i] < pivot) {
    i++;
    steps.add(animationPane -> {
         animationPane.setLowerArrowPosition(i);
    });
}

您可能需要稍微调整算法以正确分组ui表示，但这不应该太难。

quicksort方法完成后，您现在有List个Comsumer可用，可以将UI更改为下一个状态。您只需使用Iterator逐步完成动画：

Iterator<Consumer<AnimationPane>> iter = steps.iterator();
Button nextButton = new Button("Step");
button.setOnAction(evt -> {
    if (iter.hasNext()) {
         iter.next().accept(animationPane);
    }
});

快速排序算法的动画

2 个答案:

“hacky”解决方案

清洁解决方案