这是什么排序算法？

Question

更新：好的，我知道这是一种冒泡排序，但它是否效率较低，因为它在特定运行中没有交换时不会停止？它一直运行到 first 为 null。

嗨，我有一个排序算法如下。我的问题是，这是哪种排序算法？我认为这是冒泡排序，但它不会多次运行。任何想法？ 谢谢！

//sorting in descending order
struct node
{
    int value;
    node* NEXT;
}
//Assume HEAD pointer denotes the first element in the //linked list
// only change the values…don’t have to change the //pointers

Sort( Node *Head)
{
    node* first,second,temp;
    first= Head;
    while(first!=null)
    {
        second=first->NEXT;
        while(second!=null)
        {
            if(first->value < second->value)
            {
                temp = new node();
                temp->value=first->value;
                first->value=second->value;
                second->value=temp->value;
                delete temp;
            }
            second=second->NEXT;
        }

        first=first->NEXT;
    }
}

Answer 1

让我们让算法更清晰：

Sort {
   first = head;
   while (first ≠ NULL) {
      next = first.next
      while (next ≠ NULL) {
         if (first.value < next.value)
            swap first.value and next.value
         advance next
      }
      advance first
   }
}

这是一个非常低效的插入排序实现。

---

揭示插入排序特征的示例运行：

5 → 2 → 3 → 1 → nil
^   ^
f   n [swap]

2 → 5 → 3 → 1 → nil
^       ^
f       n

2 → 5 → 3 → 1 → nil
^           ^
f           n [swap]

1 → 5 → 3 → 2 → nil
^               ^
f               n

1 → 5 → 3 → 2 → nil   // insert the minimum value 1 to the beginning of the sublist
    ^   ^
    f   n [swap]

1 → 3 → 5 → 2 → nil
    ^       ^
    f       n [swap]

1 → 2 → 5 → 3 → nil  // insert the minimum value 2 to the beginning of the sublist
    ^           ^
    f           n

1 → 2 → 5 → 3 → nil
        ^   ^
        f   n [swap]

1 → 2 → 3 → 5 → nil  // insert the minimum value 3 to the beginning of the sublist
        ^       ^
        f       n

1 → 2 → 3 → 5 → nil  // insert the minimum value 5 to the beginning of the sublist
            ^   ^
            f   n

1 → 2 → 3 → 5 → nil
                ^
                f

Answer 2

这是'classic' bubble sort 和selection sort 之间的一种混合体——但更接近于经典的冒泡排序。

在经典冒泡排序中，内部循环在遍历列表/数组时交换相邻对。

在经典选择排序中，内部循环跟踪它在列表剩余部分中找到的最大值，并将其与内部循环当前正在考虑的列表部分中的第一个值交换。

问题中发布的排序类似于选择排序，因为始终使用内部循环正在考虑的子列表中的第一个值执行交换。它与选择排序不同（并且类似于经典冒泡排序），因为它在找到大于内部循环子列表的当前第一个成员的值时执行交换。

但是，它与经典冒泡排序的不同之处在于它不会交换相邻对。在经典的冒泡排序中，当内部循环完成一轮时，列表的最大元素已过滤到列表底部，但在这种变体中，最小元素已过滤到内部循环子的顶部-列表。

我将其标记为经典冒泡排序而不是选择排序的变体，因为问题中排序的性能特征与经典冒泡排序相同（O(n^2) 比较和O(n^2) 交换） ，而选择排序有O(n) 交换。

但是，经典冒泡排序和这个排序之间的另一个区别是，经典冒泡排序是稳定，而问题中的排序不是。运行排序时请考虑以下项目列表。在比较中仅使用数字 - 字母仅用于区分具有相同等级的元素。图表显示了执行的交换操作（为简洁起见，未显示比较）：

3.a  3.b   3.c   2.a   2.b   1.a
 ^                ^
 +----------------+


2.a  3.b   3.c   3.a   2.b   1.a
 ^                            ^
 +----------------------------+


1.a  3.b   3.c   3.a   2.b   2.a
      ^                 ^
      +-----------------+


1.a  2.b   3.c   3.a   3.b   2.a
            ^                 ^
            +-----------------+


1.a  2.b   2.a   3.a   3.b   3.c

注意排序结束时，2.a和2.b项的相对位置发生了变化，表示排序不稳定。

Answer 3

这几乎是冒泡排序。在交换值的链表上执行冒泡排序。检查node!=null是为了确认是否到达终点。

Answer 4

Insertion sort

它与冒泡排序非常相似，只是不是交换相邻的项目对，而是将最小的项目移动到列表的头部，然后将下一个最小的项目移动到第二个位置，依此类推。

Answer 5

类似于selection sort。在选择排序中，我们找到列表中的最小值并与第一个元素交换，并对列表中的其他元素重复相同的操作。但是在找到最小元素后我们并没有交换，而是每次我们找到一个小于第一个元素的元素（在第一遍中）我们将它与第一个元素交换。