Java 为什么这种快速排序根本不起作用？

基本上，程序要求用户提供（X，Y，Z）坐标的范围，并要求用户提供希望生成的点数。这些值被传递到对象类，在该对象类中执行快速排序算法。将值传递给writeData类后，它们将继续在文件中打印，这里是一个示例输出：其中点数为2（2组xyz坐标） 范围是1（从正无穷大到负无穷大）

从输出可以看出，它根本没有排序，如果我的算法似乎有效，为什么会出现这个问题。在过去的一个多小时里，我一直在尝试调试，但没有成功。此外，由于快速排序多维数组并没有经常使用，这是我唯一可以尝试使用的算法。不管怎样，一些或任何输入都会帮助我解决这个难题

主程序（短而甜）：

对象类

import java.io.*;

public class testplus1 {
  private static double [][] myDataPoints;
  private static double [][] sd;
  private static int myRange;
  private static int myNumPoints;

  public testplus1() throws IOException{
    myNumPoints = getNumPoints();
    myRange = getRange();
    myDataPoints = getArray();
    fillArray(myDataPoints,myRange,myNumPoints);
  }

  public void fillArray(double [][] myDataPoints,int myRange, int myNumPoints) throws IOException{
     for(int i = 0; i < myNumPoints; i++) {
      myDataPoints[0][i] =  2* (double)(Math.random () * myRange) - myRange; 
      myDataPoints[1][i] =  2* (double)(Math.random () * myRange) - myRange; 
      myDataPoints[2][i] =  2* (double)(Math.random () * myRange) - myRange; 
     sort(myDataPoints,0,0,myDataPoints.length-1);
     }
  }

 public double[][] sort(double[][] array, int key, int down, int top) throws IOException{
      double[][] a = new double[array.length][3];
      System.arraycopy(array,0,a,0, a.length);

       int i = down;
       int j = top;

       double x = a[(down + top) / 2][key];

        do {
            while (a[i][key] < x) {
                i++;
            }

            while (a[j][key] > x) {
                j--;
            }

            if (i <= j) {
                double[] temp = new double[a[i].length];

                for (int y = 0; y < a[i].length; y++) {
                    temp[y] = a[i][y];
                    a[i][y] = a[j][y];
                    a[j][y] = temp[y];
                }

                i++;
                j--;
            }
        } while (i <= j);

        if (down < j) {
            a = sort(a, key, down, j);
        }

        if (i < top) {
            a = sort(a, key, i, top);
        }
        writeData(myDataPoints);
        return a;

 }
  public static void writeData(double [][] myDataPoints) throws IOException {
    PrintWriter printWriter = (new PrintWriter ("test123"));
    for(int i = 0; i < myNumPoints; i++) {
      printWriter.println("(" + myDataPoints[0][i] + "),(" + myDataPoints[1][i] + "),(" + myDataPoints[2][i] + ")"); 
    }
    printWriter.close();
  }  

  public void setArray(double [][] dataPoints) {
    myDataPoints = dataPoints;
  }

  public double [][] getArray() {
    return myDataPoints;
  }

  public  void setNumPoints(int numPoints) {
    myNumPoints = numPoints;
  }

  public  int getNumPoints() {
    return myNumPoints; 
  }

  public void setRange(int range) {
    myRange = range; 
  }

  public int getRange() {
    return myRange; 
  }
}

import java.io.*；
公共类testplus1{
私有静态双[][]myDataPoints；
专用静态双[]sd；
私有静态int-myRange；
私有静态int myNumPoints；
公共testplus1（）引发IOException{
myNumPoints=getNumPoints（）；
myRange=getRange（）；
myDataPoints=getArray（）；
fillArray（myDataPoints、myRange、myNumPoints）；
}
公共void fillArray（双[][]myDataPoints、int-myRange、int-myNumPoints）引发IOException{
对于（int i=0；ix）{
j--；
}
如果（i查看您的
sort
方法

public double[][] sort(double[][] array, int key, int down, int top) throws IOException{
    double[][] a = new double[array.length][3];
    System.arraycopy(array,0,a,0, a.length);

您创建一个新数组
a
，并对其执行所有操作，而不是对原始输入数组（对原始数组的更改将在方法外部自动可见）。最后，返回
a
，这将起作用，但在
fillArray
中

sort(myDataPoints,0,0,myDataPoints.length-1);

您不会将其分配给任何变量。唯一更改的是
myDataPoints
的副本，而不是
myDataPoints
本身。
您应该使用
数组。排序
。使用
myDataPoints
作为第一个参数，使用自定义比较器作为第二个参数。有关更多信息，请查看位于的文档

如果你给我更多关于如何对值进行排序的信息，我可以给你一个比较器的例子。
考虑到这一逻辑，我能不能不只是划掉数组a，而使用im传递的数组，它最终会返回数组；而不是返回a；我建议先尝试使用当前版本，然后实际返回y使用排序返回的数组。这样您就知道您的算法是否正确。我需要使用快速排序进行排序，因为这是我的赋值状态。
public double[][] sort(double[][] array, int key, int down, int top) throws IOException{
    double[][] a = new double[array.length][3];
    System.arraycopy(array,0,a,0, a.length);

sort(myDataPoints,0,0,myDataPoints.length-1);