带有布尔值的冒泡排序以确定数组是否已经排序答案

【问题标题】：bubble sort with a boolean to determine whether array is already sorted带有布尔值的冒泡排序以确定数组是否已经排序
【发布时间】：2013-11-22 02:40:26
【问题描述】：

我有以下冒泡排序代码，但它根本没有排序。如果我删除我的布尔值，那么它工作正常。我知道，由于我的 a[0] 小于所有其他元素，因此没有执行任何交换，任何人都可以帮助我解决这个问题。

package com.sample;

public class BubleSort {
    public static void main(String[] args) {
        int a[] = { 1, 2, 4, 5, 6, 88, 4, 2, 4, 5, 8 };
        a = sortBuble(a);
        for (int i : a) {
            System.out.println(i);
        }

    }

    private static int[] sortBuble(int[] a) {
        boolean swapped = true;
        for (int i = 0; i < a.length && swapped; i++) {
            swapped = false;
            System.out.println("number of iteration" + i);

            for (int j = i+1; j < a.length; j++) {

                if (a[i] > a[j]) {
                    int temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                    swapped = true;
                }
            }
        }

        return a;
    }
}

【问题讨论】：

标签： java sorting bubble-sort

【解决方案1】：

你的冒泡排序错了？

    private static int[] sortBuble(int[] a) {
        boolean swapped = true;
        int n = a.length;
        for (int i = 0; i < n && swapped; i++) {
            swapped = false;
            int newn = 0;
            System.out.println("number of iteration" + i);

            for (int j = 1; j < a.length; j++) {

                if (a[j-1] > a[j]) {
                    int temp = a[j-1];
                    a[j-1] = a[j];
                    a[j] = temp;
                    swapped = true;
                    newn = j;
                }
            }
            n = newn;
        }

        return a;
    }

【讨论】：

你只用 j 编写了我的代码，但我认为它与我的代码没有什么不同
@ankit 讨论起来很有趣，但您描述了一个不同的过程，它可以对数组进行排序，但工作方式略有不同。它们是不同的。
@SteveP.：您是否愿意详细说明未优化的内容以及应如何优化？更新了答案。
@imslavko 看到我的回答。
好吧，老实说，我不太在意：冒泡排序是一种介绍性算法，一两个启发式算法不会让它变得更好。渐近优化确实很重要，@ankit 更好地继续前进。但是为了人性，请注意在您的教科书中查找算法（CLRS，Sedgwick 工作得很好）或至少在维基百科中查找。

【解决方案2】：

这与您的基本相同，但工作效率更高：

private static int[] bubblesort(int[] nums)
{
    boolean done = false;

    for (int i = 0;  i < nums.length && !done; i++)
    {
        done = true;

        for (int j = nums.length-1; j > i; j--)
        {
            if (nums[j] < nums[j-1])
            {
                int temp = nums[j];
                nums[j] = nums[j-1];
                nums[j-1] = temp;
                done = false;
            }
        }
    }

    return nums;
}

在第 i^th 次迭代结束时，我们知道前 i 个元素已排序，因此我们不再需要查看它们。我们需要布尔值来确定是否需要继续。如果没有进行交换，那么我们就完成了。我们可以删除布尔值，它仍然可以工作，但效率会降低。

【讨论】：

【解决方案3】：

它被称为标记冒泡排序。它主要有助于节省时间。它检查数组位置是否已排序。如果它被排序，它会中断，并移动到第二次执行。

代码可以改写为：-

for (int j = 1; j < a.length; j++) {

            if (a[j-1] > a[j]) {
                int temp = a[j-1];
                a[j-1] = a[j];
                a[j] = temp;
                swapped = true;             
            }
        }
        if(!swapped)
           break;
    }

【讨论】：