C 哪一种是气泡型的，还是两者都是？

这两种算法按升序对日期进行排序。这两种排序算法称为冒泡排序吗

1） 首先，它使用swap从整个数组中找到最小的，并将其放入索引0中，依此类推

或者换句话说-->在每次迭代一次后，它使用交换在数组开始处推送最小值

for (int i = 0; i != arrayEnd - 1; i++) {
    for (j = i + 1; j != arrayEnd; j++) {
        if (A[i] > A[j]) {
            temp = A[i];
            A[i] = A[j];
            A[j] = temp;
        }
    }
}

while (!isSorted) {
    isSorted = true;
    for (int i = 0; i < lastUnsorted; i++) {  // lastUnsorted = arrayLength - 1;
        if (A[i] > A[i + 1]) {
            temp = A[i];
            A[i] = A[i + 1];
            A[i + 1] = temp;
            isSorted = false;
        }
    }
    lastUnsorted--; 
}

2） 在每次迭代一次之后，它使用swap在数组末尾推送最大值

for (int i = 0; i != arrayEnd - 1; i++) {
    for (j = i + 1; j != arrayEnd; j++) {
        if (A[i] > A[j]) {
            temp = A[i];
            A[i] = A[j];
            A[j] = temp;
        }
    }
}

while (!isSorted) {
    isSorted = true;
    for (int i = 0; i < lastUnsorted; i++) {  // lastUnsorted = arrayLength - 1;
        if (A[i] > A[i + 1]) {
            temp = A[i];
            A[i] = A[i + 1];
            A[i + 1] = temp;
            isSorted = false;
        }
    }
    lastUnsorted--; 
}

while（！isSorted）{
isSorted=true；
对于（int i=0；iA[i+1]）{
温度=A[i]；
A[i]=A[i+1]；
A[i+1]=温度；
isSorted=假；
}
}
最后未排序--；
}

---

它们都称为冒泡排序？

是-都是冒泡排序的变体。 变量1）不是最优的-每种情况都是O（N^2）

---

变量2）更好-内循环每次迭代都会跳过一次比较，因为它知道一个元素是否在排序位置。

在这两种情况下，它都遵循bubblesort，但在第二种情况下，通过删除数组末尾的最大元素，冒泡排序变得有效

现在，当数组有一个最大元素的长排序尾部时，这仍然会进行很多不必要的迭代，比如说，第一个k元素是k，k-1，…，1，然后是k+1到100000000。标准气泡排序将（几乎）通过整个数组k次

但你可以在这件事上试试：

while(!isSorted){
        isSorted = true;
        int lastSwap = lastUnsorted;
        for (int i = 0; i < lastSwap; i++) {  // lastUnsorted = arrayLength - 1;
            if (A[i] > A[i + 1]) {
                temp = A[i];
                A[i] = A[i + 1];
                A[i + 1] = temp;
                isSorted = false;
                currentSwap = j; 
            }
        }
        lastUnsorted--; 
        lastSwap = currentSwap; 
    }

while（！isSorted）{
isSorted=true；
int lastSwap=最后未排序；
对于（int i=0；iA[i+1]）{
温度=A[i]；
A[i]=A[i+1]；
A[i+1]=温度；
isSorted=假；
currentSwap=j；
}
}
最后未排序--；
lastSwap=currentSwap；
}
经典的冒泡排序有O（n^2）和Ω（n）渐近运行时间。这是我的第二个变种。第一个变量更类似于选择排序O（n^2）Ω（n^2），但没有找到最小值

简单地说，我的第一个变体比经典选择排序效率低，尽管它们非常相似

我的答案是否定的。它们并非都是泡沫型的。第二种是气泡排序
 从理论上讲，冒泡排序的最大元素在每次迭代后都会像冒泡一样上升到最后。算法有一个名字，最小的元素从一开始就像岩石一样下沉，但我似乎记不起来了。无论哪种方式，它们都是相同的算法。对冒泡排序（一个元素冒泡到“排序”的一端）最乐观的解释是由这两种算法完成的。但是，实际值会比较相邻元素。此外，您的第二个实现包括交换检测，这是一种提供提前退出选项的优化。O（n）的最佳情况发生在一个已经排序的序列上，而第一个实现仍然是O（n^2）。变量1）但是外循环每次迭代都会跳过一次比较，因为在1次迭代后它设置了一个[0]并且不再看那里（还有内循环），在2次迭代后它设置了一个[1]并且不再看那里（还有内环）等等。我认为它们在这个意义上是相等的。或者我错了？我认为变量1）和2）在效率意义上是相等的。“在第二种情况下，冒泡排序通过删除数组末尾的最大元素而变得高效”，而在第一种情况下，冒泡排序通过删除数组开头的最小元素而变得高效。我试着在两种变体中使用swapCounter来测试自己，在这两种情况下，我得到了相同的交换次数。