Java中的双向气泡排序？

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

换句话说，中的

将从左到右首先携带最大值

但当它到达
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); 

public void bubbleSort（）{
int out，in；//nElems在我的例子中是4，因为我的数组中有4个元素
for（out=nElems-1；out>1；out--）//外循环向后
for（in=out；in>1；in--）//内部循环向后
if（a[in]public void双向泡泡排序（）
{
int left=0，right=a.length-1；
while（左<右）
{
用于（int pos=左；pos<右；pos++）
{
如果（a[pos]>a[pos+1]）
互换（pos，pos+1）；
}
对--；
用于（int pos=右；pos>左；pos--）
{
如果（a[pos]
公共无效双向气泡排序（）
{
int left=0，right=a.length-1；
while（左<右）
{
用于（int pos=左；pos<右；pos++）
{
如果（a[pos]>a[pos+1]）
互换（pos，pos+1）；
}
对--；
用于（int pos=右；pos>左；pos--）
{
如果（a[pos]
我建议您将该方法分成您可以理解的块，例如：

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--);
}

输出：

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

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

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--);
}

输出：

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

boolean f1=false，f2=false；
外部：
对于（int i=0；i=arr[j+1]）{
f1=真；
int t=arr[j]；
arr[j]=arr[j+1]；
arr[j+1]=t；
}
如果（arr[arr.length-j-1]
boolean f1=false，f2=false；
外部：
对于（int i=0；i=arr[j+1]）{
f1=真；
int t=arr[j]；
arr[j]=arr[j+1]；
arr[j+1]=t；
}
if（arr[arr.length-j-1]双向气泡排序仅使用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);
        }
    }
}

public void bubbleSort（）{
对于（int out=0；out双向气泡排序，仅使用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);
        }
    }
}

public void bubbleSort（）{
对于（int out=0；out双向气泡排序，排序变量：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;
}
//-------------------------------------------//

//-------------------------------------------//
//双向气泡排序-共尾排序
public void bidirBubbleSort（）{
对于（int i=1；i=i；j--）
if（array[j]双向冒泡排序，排序变量：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;
}
//-------------------------------------------//

//-------------------------------------------//
//双向气泡排序-共尾排序
public void bidirBubbleSort（）{
对于（int i=1；i=i；j--）
如果（数组[j]这是家庭作业吗？只是问，因为我在实践中很少找到气泡排序是的，这是某人。气泡排序很糟糕-真实的故事，但我必须完成这个项目。我猜我不会得到太多帮助，所以如果是家庭作业？甚至没有线索？你会得到一些帮助（特别是线索），但如果有些人觉得你想找人帮你做作业，他们就不想提供代码。有些人会怨恨你试图隐瞒这是作业，如果是的话。只是为了跟进赵的评论，你可能应该使用一个
作业
标签。这是作业吗？只是问我，因为我不知道ely在实践中发现泡泡排序是的，它是某人。泡泡排序很糟糕-真实的故事，但我必须完成这个项目。我猜我不会得到太多帮助，所以如果是家庭作业？甚至没有线索？你会得到一些帮助（特别是线索），但如果有些人觉得你想找人帮你做作业，他们就不想提供代码。有些人可能会不满你试图隐藏这是作业，如果是作业。只是为了跟进赵的评论，有一个
作业
标记，你可能应该使用。这一行导致数组越界异常：如果（a[pos]>a[pos+1]）我的错误，我是在左减而不是增加它。这行导致数组越界异常：如果（a[pos]>a[pos+1]）我的错，我是递减左而不是递增。如果要返回排序列表，那么原始列表应该保持不变。克隆它或其他东西，或者让排序方法返回其他东西，甚至什么都不返回。（例如，如果它是空的，那么任何有线索的人都应该清楚它对原始列表的修改。）这是一个很好的观点。现在更新代码以适应这种更改。如果要返回已排序的列表，则原始列表应保持不变。克隆它或其他东西，或让排序方法返回其他东西，甚至什么都不返回。（例如，如果它是空的，则任何有线索的人都会看到它对原始列表的修改。）这是一个很好的观点。现在更新代码以适应这种变化。