我需要在Java中实现以下内容。

输入：整数数组

输出：重新排列数组以具有以下内容：

假设原始数组中的第一个元素的值为x

在新数组中，假设x在位置I，即data[I] = x。然后，对所有x和所有j > I使用data[j] <= x。这意味着x的"左侧"的所有值均小于或等于x，而"右侧"的所有值均大于x。

一个示例如下：假设数组具有以下初始顺序的元素：4,3,9,2,7,6,5。应用算法后，您将获得：3,2,4,5,9,7,6。也就是说，最左边的元素4放置在结果数组中，以便所有小于4(2和3)的元素都位于其左侧(不按特定顺序排列)，所有大于4的元素都位于其右侧(以没有特定的顺序)。

该算法没有空间要求，只是可以在O(n)时间内解决问题。

我已经实现了存储桶排序，但是在代码方面遇到了一些困难。

public class Problem4

{

public static void partition(int[] A)

{

int x = A[0];

int l = A.length;

int[] bucket = int [];

for(int i=0; i

bucket[i]=0;

}

for (int i=0; i

bucket[x[i]]++;

}

int outPos=0;

for(int i=0; i

for(int j=0; j

x[outPos++]=i;

}

}

}

public static void main(String[] args) {

// TODO Auto-generated method stub

int[] A = {4,3,9,2,7,6,5};

System.out.println("Before partition:");

for(int i = 0; i < A.length; i++)

{

System.out.print(A[i] +"");

}

partition(A);

System.out.println("After partition:");

System.out.println("Before partition:");

for(int i = 0; i < A.length; i++)

{

System.out.print(A[i] +"");

}

}

}

这些行：

int[] bucket = int[]，

bucket[x[i]]++;，以及

x[outpost++] = i;

给我带来麻烦。我收到错误

The type of expression must be an array type but is resolved to an int.

问题源于我试图创建一个名为bucket的新数组的第一行。我将不胜感激任何建议！谢谢！

会编译吗？ int[] bucket = int [];

@ Kaushal28不！

哈哈@JacobG ....

也许只有一点(鉴于代码中有语法错误)，但我不会选择partition作为存储桶排序中分发方法的名称。 zh.wikipedia.org/wiki/Bucket_sort

如果您构建一个最小的可重现示例并提出诸如"我如何创建数组"之类的问题，这将是一个更好的问题，尽管诸如此类的问题的答案可能在教科书或教程中可能会更好(因为您可能会漏掉它 学习语言基础所需的许多周围环境，这只会引发更多的问题)。

您可以使用的另一种方法是使用QuickSort的标准分区算法。

我已经修改了您的代码和以下代码

public class Problem4

{

/* This function takes last element as pivot,

places the pivot element at its correct

position in sorted array, and places all

smaller (smaller than pivot) to left of

pivot and all greater elements to right

of pivot */

public static int partition(int arr[], int low, int high)

{

int pivot = arr[high];

int i = (low-1); // index of smaller element

for (int j=low; j

{

// If current element is smaller than or

// equal to pivot

if (arr[j] <= pivot)

{

i++;

// swap arr[i] and arr[j]

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

}

}

// swap arr[i+1] and arr[high] (or pivot)

int temp = arr[i+1];

arr[i+1] = arr[high];

arr[high] = temp;

return i+1;

}

public static void main(String[] args) {

// TODO Auto-generated method stub

int[] A = {4,3,9,2,7,6,5};

System.out.println("Before partition:");

for(int i = 0; i < A.length; i++)

{

System.out.print(A[i] +"");

}

// swap and call the standard partition algo of QuickSort

// on last element pivot. swap arr[low] and arr[high]

int low = 0;

int high = A.length-1;

int temp = A[low];

A[low] = A[high];

A[high] = temp;

partition(A, low, high);

System.out.println("

After partition:");

for(int i = 0; i < A.length; i++)

{

System.out.print(A[i] +"");

}

}

}

产出

Before partition:

4 3 9 2 7 6 5

After partition:

3 2 4 5 7 6 9

希望能帮助到你！

我认为您不需要诉诸于水桶排序。 相反，您可以简单地遍历数组，将小于拆分值的元素放在前面，将大于拆分值的元素放在后面。 我们可以使用两个变量front和back来跟踪数组前面和后面的插入位置。 从数组中的位置1开始，如果该值小于分割值，则将其放置在front处，并递增front和当前索引。 如果值更大，我们将其交换为back的值并递减back，但保留当前索引。

这是一些代码说明：

public static void main(String[] args)

{

int[] A = {4,3,9,2,7,6,5};

sort(A);

System.out.println(Arrays.toString(A));

}

public static void sort(int[] arr)

{

int split = arr[0];

int front = 0;

int back = arr.length-1;

for(int i=1; front != back; )

{

if(arr[i] <= split)

{

arr[front] = arr[i];

front += 1;

i++;

}

else

{

swap(arr, i, back);

back -= 1;

}

}

arr[front] = split;

}

public static void swap(int[] arr, int i, int j)

{

int t = arr[i];

arr[i] = arr[j];

arr[j] = t;

}

输出：

[3, 2, 4, 7, 6, 5, 9]

谢谢！ 这要简单得多！ 我说运行时间为O(n)是否正确？

是的，您只需遍历数组的n个元素，分配或交换2个元素。