Java中的双向冒泡排序？答案

【问题标题】：Bidirectionnal Bubble Sort in Java?Java中的双向冒泡排序？
【发布时间】：2010-09-30 15:38:28
【问题描述】：

我需要在我的代码中实现双向冒泡排序。

换句话说，in 将从左到右首先携带最大值。

但是当它到达out时，它应该反向并从右到左携带最小值。

建议我在当前索引之外实现另一个out 索引。

这是我目前所拥有的——只有 2 个循环。我猜我必须以某种方式将它们结合起来？

    public void bubbleSort() {
    int out, in; // nElems in my case is 4, because I have 4 elements in my array

    for(out=nElems-1; out>1; out--) // outer loop backward
        for(in=out; in>1; in--) // inner loop backward
            if(a[in] < a[in-1])
                swap(in, in-1);

    for(out=0; out<nElems; out++) // outer loop forward
        for(in=0; in<out; in++) // inner loop forward
            if(a[in] > a[in+1])
                swap(in, in+1);

【问题讨论】：

这是作业吗？只问，因为我在实践中很少发现冒泡排序
是的，它是 SB。冒泡排序很烂——真实的故事，但我必须完成这个项目。
如果是家庭作业，我猜我不会得到太多帮助？一点线索都没有？
你会得到一些帮助（尤其是线索），但是如果有些人觉得你在找人帮你做作业，他们就不想提供代码。如果是的话，有些人会反感你试图隐瞒这是家庭作业。
只是为了跟进 cHao 的评论，您可能应该使用 homework 标签。

标签： java algorithm sorting bubble-sort

【解决方案1】：

    public void bidirectionalBubbleSort()
    {
       int left = 0, right = a.length-1;
       while (left < right)
       {
          for (int pos = left; pos < right; pos++)
          {
             if (a[pos] > a[pos+1])
                swap(pos, pos+1);
          }
          right--;


          for (int pos = right; pos > left; pos--)
          {
             if (a[pos] < a[pos-1])
               swap(pos, pos-1);
          }
          left++;
       }
   }

【讨论】：

这一行导致数组越界异常：if (a[pos] > a[pos+1])
我的错，我向左递减而不是递增

【解决方案2】：

我建议您将方法拆分为您可以理解的块，例如：

public static boolean swap(int[] numbers, int i, int j) {
    int temp = numbers[i];
    numbers[i] = numbers[j];
    numbers[j] = temp;
    return true;
}

static boolean leftSide(int[] numbers, int i, int j) {
    boolean swapped = false;
    for (int k = i; k < j; k++)
        if (numbers[k] > numbers[k + 1])
            swapped = swap(numbers, k, k + 1);
    return swapped;
}

static boolean rightSide(int[] numbers, int i, int j) {
    boolean swapped = false;
    for (int k = j; k > i; k--)
        if (numbers[k] < numbers[k - 1])
            swapped = swap(numbers, k, k - 1);
    return swapped;
}

public static void cocktailSort(int[] numbers) {
    boolean swapped = true;
    int i = -1;
    int j = numbers.length - 1;

    while (i++ < j && swapped)
        if (swapped = leftSide(numbers, i, j))
            swapped = rightSide(numbers, i, j--);
}

并对其进行测试：

public static void main(String[] args) {
    int x[] = new int[] { 2, 6, 3, 7, 8, 3, 7, 5, 4 };
    cocktailSort(x);
    System.out.println(java.util.Arrays.toString(x));
}

输出：

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

【讨论】：

如果你要返回排序后的列表，那么原始列表应该保持不变。克隆它或其他东西，或者让 sort 方法返回其他东西，甚至什么都没有。（例如，如果它是无效的，那么它对原始列表的修改对于任何有线索的人来说都是显而易见的。）
这是一个好点。现在更新了代码以适应这种变化。

【解决方案3】：

    boolean f1 = false, f2 = false;
    outer:
    for (int i=0; i < arr.length-1; i++)
           for (int j=i; j< arr.length - i -1; j++) {

               if(arr[j] >= arr[j+1]){
                   f1 = true;
                   int t = arr[j];
                   arr[j] = arr[j+1];
                   arr[j+1] = t;
               }

               if(arr[arr.length - j -1] <= arr[arr.length - j - 2]){

                   f2 = true;
                   int t = arr[arr.length - j -2];
                   arr[arr.length - j -2] = arr[arr.length - j -1];
                   arr[arr.length -j -1] = t;
               }

               /**
                * @param k: iterator variable thats prints each pass..(optional)
                */
               for (int k:arr)
                   System.out.print(" "+k);
               System.out.println("    "+i);

               //Ultimate break condition
               if(j == arr.length - j -2 && (!f1 && !f2))
                   break outer;


           }

【讨论】：

【解决方案4】：

双向冒泡排序仅使用 2 个循环 & 2 个索引 变量。

public void bubbleSort(){
    for(int out=0;out<nElems/2;out++){
        boolean forward = true;
        for (int in = out;in !=(forward ? out-1 : out)
                         ;in = forward ? in + 1 : in - 1)
        {
            if (in == nElems - (out + 1))
                forward = false;
            if (a[forward ? in + 1 : in] < a[forward?in:in-1])
                swap(forward ? in + 1 : in - 1, in);
        }
    }
}

【讨论】：

【解决方案5】：

双向冒泡排序，排序变量：array[]

//-------------------------------------------//
//biderctioanal bubble sort - coctail sort
public void bidirBubbleSort(){
    for(int i=1; i<length/2; i++){
        for(int j=0; j<length-i; j++)
            if(array[j]>array[j+1])
                swap(j, j+1);
        for(int j=length-i; j>=i; j--)
            if(array[j]<array[j-1])
                swap(j, j-1);
    }
}
//-------------------------------------------//
//swap 2 elements
public void swap(int index1, int index2){
    int temp=array[index1];
    array[index1]=array[index2];
    array[index2]=temp;
}
//-------------------------------------------//

在 10_000 个随机选择的元素上，标准冒泡排序在 410 毫秒内完成，双向冒泡排序在 319 毫秒内完成

【讨论】：