Question

这是一个实验室作业，我已经奋斗了一个星期了。这个问题还有更多，我迷失了。我可以在某个方向上使用提示，而不是要求答案。如果我发布了错误的内容，我的大脑就被炸了，我很抱歉。任何帮助都将不胜感激。

一个。创建两个名为lessser和more的新数组。这些将分别用于存储小于或大于枢轴元素的“a”元素。

湾循环穿过枢轴之外的所有“a”元素。如果元素小于pivot，则将其复制到较小的数组中。如果元素大于或等于pivot，则将其复制到更大的数组中。

℃。创建一个名为result的新数组，其长度与“a”相同。

d。将较小元素复制到结果中。

即将pivot元素本身复制到结果中。

F。将更大的元素复制到结果中。

克。返回分区数组结果。

编写实现此算法的方法public static double[] partition(double[] a)。

public class Lab6 {
public static void main(String[] args) {

}

public static double[] loadRandom(double[] randomNumbersArray)
{
    randomNumbersArray = new double[100000];

    // looping through to assign random values from 1 - 100000
    for (int i = 0; i < randomNumbersArray.length; i++) {
        randomNumbersArray[i] = (int)(Math.random() * 2000000000); 
    }

    return randomNumbersArray;
}

public static double[] partitionInPlace(double[] a)
{
    loadRandom(a);
    double pivotValue = a[0];
    int j = 0;  //j keeps track of which elements have already been placed

    //start by swapping the pivot value with the value at the rightmost index
    a[0] = a[a.length-1];
    a[a.length-1] = pivotValue;

    //go through the array (except for the rightmost index) to find the elements
    //that are < pivotValue
    for (int i = 0; i < a.length-1; i++) {
        //if a[i] is < pivotValue, then swap a[i] and a[j] and incremement j
        if (a[i] < pivotValue) {
            double temp = a[i];
            a[i] = a[j];
            a[j] = temp;

            j++;
        }
    }

    //now move the pivot back from its position on the right
    double temp = a[j];
    a[j] = a[a.length-1];
    a[a.length-1] = temp;

    //return the partitioned array
    return a;
}

public static double[] partition(double[] a) 
{
    double lesser;
    double greater;
    double result;

    return a;
}
}

Answer 1

假设您从长度为a的数组l开始。

然后你应该创建两个长度为lesser的数组greater和l-1（因为所有值都可能小于或大于数据透视）。

double[] lesser = new double[a.length() - 1];
double[] greater = new double[a.length() - 1];

之后，只需（如练习中）将数据复制到这些数组中。跟踪两个数组的长度，如lesserlength = 0; greaterlength = 0;，并在每次插入值时递增。这样，您就可以知道在lesser和greater中插入下一个值的位置。

最终，您可以将较小的副本复制到长度为l的新数组中。

double[] result = new int[a.length()];

您知道lesserlength + 1 + greaterlength == a.length()

您可以使用System.arraycopy(source, srcpos, dest, dstpos, len)将lesser和greater复制到结果中。

这应该足以帮助你。

Answer 2

这应该可以解决问题：

private static double[] partition(double[] a) {

    //choose some pivot, perhaps randomly?
    Random r = new Random();
    double pivot = a[r.nextInt(a.length)];

    //create lesser and greater arrays
    double[] lesser = new double[a.length];
    double[] greater = new double[a.length];

    //loop through members of a
    int lesserIndex = 0;
    int greaterIndex = 0;

    for (double number : a) {
        if (number < pivot) {
            lesser[lesserIndex++] = number;
        } else {
            greater[greaterIndex++] = number;
        }
    }

    //create result array
    double[] result = new double[a.length];
    int resultIndex = 0;

    //copy in lesser
    for (int i=0; i<lesserIndex; i++) {
        result[resultIndex++] = lesser[i];
    }

    //copy in pivot
    result[resultIndex++] = pivot;

    //copy in greater
    for (int i=0; i<greaterIndex; i++) {
        result[resultIndex++] = greater[i];
    }

    //return result
    return result;

}

使用此算法对数组进行分区

2 个答案: