Question

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

输入：整数数组

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

假设原始数组中的第一个元素具有值x 在新数组中，假设x位于位置I，即data[I] = x。然后，data[j] <= x适用于所有x和所有j > I。这意味着＆＃34; left＆＃34;的所有值。 x小于或等于x和＆＃34;右＆＃34;的所有值大于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.length; i++){
            bucket[i]=0;
        }
        for (int i=0; i<l; i++){
            bucket[x[i]]++;
        }
        int outPos=0;
        for(int i=0; i<bucket.length; i++){
            for(int j=0; j<bucket[i]; 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;

让我烦恼。我收到了错误

表达式的类型必须是数组类型，但解析为int。

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

Answer 1

我认为你不需要采取斗式排序。相反，您可以简单地遍历数组，在前面放置小于分割值的元素，在后面放置更大的元素。我们可以使用两个变量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]

Answer 2

您可以使用的另一种方法是使用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<high; 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("\nAfter 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

希望它有所帮助！

存储桶排序算法代码问题

2 个答案: