Java 使用布尔值进行气泡排序，以确定数组是否已排序

我有下面的冒泡排序代码，但它根本不排序。如果我删除布尔值，则其工作正常。我明白，由于我的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;
    }
}

package.com.sample；
公共类BubleSort{
公共静态void main（字符串[]args）{
INTA[]={1,2,4,5,6,88,4,2,4,5,8}；
a=可排序的（a）；
对于（int i:a）{
系统输出打印LN（i）；
}
}
私有静态int[]sortBuble（int[]a）{
布尔交换=真；
对于（int i=0；ia[j]）{
int temp=a[i]；
a[i]=a[j]；
a[j]=温度；
交换=真；
}
}
}
返回a；
}
}

您的冒泡排序错误

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

私有静态int[]sortBuble（int[]a）{
布尔交换=真；
int n=a.长度；
对于（int i=0；ia[j]）{
内部温度=a[j-1]；
a[j-1]=a[j]；
a[j]=温度；
交换=真；
newn=j；
}
}
n=newn；
}
返回a；
}

您的冒泡排序错误

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

私有静态int[]sortBuble（int[]a）{
布尔交换=真；
int n=a.长度；
对于（int i=0；ia[j]）{
内部温度=a[j-1]；
a[j-1]=a[j]；
a[j]=温度；
交换=真；
newn=j；
}
}
n=newn；
}
返回a；
}

您的冒泡排序错误

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

私有静态int[]sortBuble（int[]a）{
布尔交换=真；
int n=a.长度；
对于（int i=0；ia[j]）{
内部温度=a[j-1]；
a[j-1]=a[j]；
a[j]=温度；
交换=真；
newn=j；
}
}
n=newn；
}
返回a；
}

您的冒泡排序错误

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

私有静态int[]sortBuble（int[]a）{
布尔交换=真；
int n=a.长度；
对于（int i=0；ia[j]）{
内部温度=a[j-1]；
a[j-1]=a[j]；
a[j]=温度；
交换=真；
newn=j；
}
}
n=newn；
}
返回a；
}

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

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

私有静态int[]bubblesort（int[]nums）
{
布尔完成=假；
对于（int i=0；ii；j--）
{
if（nums[j]

---

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

这与您的基本相同，但有效且更高效：

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

私有静态int[]bubblesort（int[]nums）
{
布尔完成=假；
对于（int i=0；ii；j--）
{
if（nums[j]

---

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

这与您的基本相同，但有效且更高效：

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

私有静态int[]bubblesort（int[]nums）
{
布尔完成=假；
对于（int i=0；ii；j--）
{
if（nums[j]

在英国