Question

首先，我确实了解for循环的作用和if块的作用

我不理解的部分是!isSorted，如果最初将isSorted设置为false，!isSorted是否意味着它将while循环设置为true？

如果是，在发生交换并将isSorted标记为false之后，循环又如何进行？

如果不能清楚表达自己的歉意

它在工作，但是为什么在工作？

public class BubbleSorting {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {

        int[] massiv =  {2,14,8,90,97,44,23,78, 11,1,46, 55, 105,64};
        int buffer;
        boolean isSorted = false;

        while(!isSorted){
            isSorted = true;
            for(int i = 0; i<massiv.length-1; i++){
                if(massiv[i]>massiv[i+1]){
                    buffer = massiv[i];
                    massiv[i] = massiv[i+1];
                    massiv[i+1] = buffer;
                    isSorted = false;
                }
            }
        }
        System.out.println(Arrays.toString(massiv));
    }
}

Answer 1

第一个isSorted设置为false，因此!isSorted表示isSorted变量值及其true的取反。因此它将进入while循环内部。

然后在其内部首先将其设置为true。并且如果发生交换，它将设置为false。因此，在发生交换之前，isSorted为假。这意味着!isSorted是正确的。因此，直到发生交换时，循环才会继续。

当没有发生交换时。 isSorted为true，!isSorted为false。然后就存在while循环

Answer 2

!操作不会更改变量的值，但会反转其使用的结果表达式。

boolean first = true;
if (first) {} //`first` is equal to "true" and the expression is "true";

boolean second = !first;
if (second) {}  //`first` is still equal to "true".
                //`second` is equal to "false".
                //the expression is "false".


if (!second) {}     //`first` is still equal to "true".
                    //`second` is still equal to "false".
                    //the expression is "true".

这是气泡排序算法中的一种优化形式。每次代码执行一次传递时，它都假定列表现在已排序，直到传递中发生交换为止，这意味着尚未对数组/列表进行排序。

让我们打破代码：

public static void main(String[] args) {

    int[] massiv =  {2,14,8,90,97,44,23,78, 11,1,46, 55, 105,64}; 
    int buffer;
    boolean isSorted = false; // massiv is not sorted,

    while(!isSorted){   // ! isSorted == (is not sorted [yup captain obvious])

        /*here's the tricky part*/
        isSorted = true; // assume the array is sorted already


        for(int i = 0; i < massiv.length-1; i++) { // for each element of the array... 
            if(massiv[i]>massiv[i+1]) { /* ... check if the current value 
                                            is greater than the next */
                // if it's the case, swap those values
                buffer = massiv[i];
                massiv[i] = massiv[i+1];
                massiv[i+1] = buffer;
                isSorted = false; /* the array was not sorted because there
                                     was at least one swap */
            }
        }
    }
    System.out.println(Arrays.toString(massiv));

因此，基本上，每次传递都是对数组进行排序的验证，如果传递遇到未排序的部分，它将进行交换并再次检查代码，直到对数组进行排序。

Answer 3

Tigran，为回应您的最新评论，我将尝试以一种易于理解的简单方式进行解释。

Java或大多数其他编程语言中的 conditional （或条件语句）是根据特定的 condition 是true还是false来执行不同动作的语句

在这种情况下，条件是isSorted的值。变量isSorted是一个布尔变量，因此其值可以为 true 或 false 。

当我们到达一行说：

while(isSorted)

我们正在检查括号中的条件，即isSorted。这意味着我们正在检查isSorted是否为true。如果是，则执行操作（进入循环）。如果没有，我们就不会。

“！”符号表示取反-在条件语句中的条件之前使用时，表示“与条件相反”。

所以在这一行：

while(!isSorted)

我们正在检查isSorted条件的相反条件是否为true，表示isSorted为false。如果是，则执行操作（进入循环）。如果没有，我们就不会。

因此，在这种情况下，仅当isSorted的值为false时，我们才进入while循环。如果该值为true，我们将停止进入循环。

我无法理解冒泡排序中的while循环条件

3 个答案: