Question

我必须用随机数据库编写一个快速排序算法，所以我创建了以下代码：

public void quickSort(int left, int right)
{
    if(a.length == 1)
    {
        System.out.println("Only one element.");
    }
    else
    {
        int l = left;
        int r = right;
        if(right > left)
        {
            Random rand = new Random();
            int num = left + rand.nextInt(right - left);
            int p = a[num];

            int tmp = a[r];
            a[r] = a[num];
            a[num] = tmp;
            num = r;
            r--;


            while(r > l)
            {
                while((l<right)&&(a[l]<=p))
                {
                    l++;
                }
                while((r > left)&&(a[r]>=p))
                {
                    r--;
                }
                if(l < r)
                {
                    tmp = a[l];
                    a[l] = a[r];
                    a[r] = tmp;
                }
            }

            if(a[l] > p) {
                tmp = a[l];
                a[l] = a[num];
                a[num] = tmp;
            }

            quickSort(left,l-1);
            quickSort(l+1,right);
        }

       }
    }

“a”应该是一个int-Array。正如你所看到的，只要我得到我的随机数据，我就把它与数组的最后一个元素交换，所以我不会对算法有任何问题，但我想知道是否有可能让数据保持在它的位置然而，随机的位置并没有问题地对它进行排序。 Thx提前。

Answer 1

是的，有。基本上，我们可以使不平等更严格：将a[l]<=p更改为a[l]<p，将a[r]>=p更改为a[r]>p。这将有助于处理数组中可能存在相同元素的情况，因此您可以摆脱l<right和left<r条件。

不能保证枢轴位于l的正确位置，但是，a[left...l]仍然是<=p而a[l+1...right]将是>=p，这足以让算法发挥作用。

以下是您的代码的变体。条件if(l < r)被修改为if(l <= r)，在内部，l++;和r--;被添加以跳过我们刚刚交换的两个元素。此外，递归调用更新为(left,r)和(l,right)，因为现在没有保证pivot元素的位置。

public void quickSort(int left, int right)
{
    if(a.length == 1)
    {
        System.out.println("Only one element.");
    }
    else
    {
        int l = left;
        int r = right;
        if(right > left)
        {
            Random rand = new Random();
            int num = left + rand.nextInt(right - left);
            int p = a[num];

            while(r > l)
            {
                while(a[l]<p)
                {
                    l++;
                }
                while(a[r]>p)
                {
                    r--;
                }
                if(l <= r)
                {
                    int tmp = a[l];
                    a[l] = a[r];
                    a[r] = tmp;
                    l++;
                    r--;
                }
            }

            quickSort(left,r);
            quickSort(l,right);
        }
    }
}

Quicksort算法，在数组中间随机旋转

1 个答案: