Question

我的意思是...部分，完整或反向排序的数组。

我已经尝试了以下内容：随机，完全排序，几乎排序，部分排序，重新排序，并且当它完全排序时，气泡的数量较少。在所有其他情况下，它都是一样的。

int selectionSort(int a[], int l, int r) {
    int count = 0;
    for (int i = l; i < r; i++) {
        int min = i;
        for (int j = i + 1; j <= r; j++) {
            if (a[j] < a[min]) min = j;
            count++;
        }   
        if (i != min) swap(a[i], a[min]);
    }
    return count;
}


int bubbleSort(int a[], int l, int r) {
    int count = 0;
    bool flag = false;
    for (int i = l; i < r; i++) {
        for (int j = r; j > i; j--) {
            if (a[j-1] > a[j]) {
                if (flag == false) flag = true;
                swap(a[j - 1], a[j]);
            }
            count++;
        }
        if (flag == false) break;
    }
    return count;
}

计数返回比较次数BTW。

Answer 1

在简单的平均情况Θ（n ²）算法中，选择排序几乎总是优于冒泡排序。

Source: Wikipedia

Answer 2

我已经在评论中暗示了这一点，但是这里有一些更新的代码，包括比较和交换/交换，并说明对于某些随机输入 交换/交换的数量 是选择排序优于冒泡排序的地方。

#include <iostream>
#include <vector>
#include <utility>
#include <cassert>

using namespace std;

struct Stats { int swaps_ = 0, compares_ = 0; };

std::ostream& operator<<(std::ostream& os, const Stats& s)
{
    return os << "{ swaps " << s.swaps_
              << ", compares " << s.compares_ << " }";   
}

Stats selectionSort(std::vector<int>& a, int l, int r) {
    Stats stats;
    for (int i = l; i < r; i++) {
        int min = i;
        for (int j = i + 1; j <= r; j++) {
            if (a.at(j) < a.at(min)) min = j;
            ++stats.compares_;
        }   
        if (i != min) {
            swap(a.at(i), a.at(min));
            ++stats.swaps_;
        }
    }
    return stats;
}


Stats bubbleSort(std::vector<int>& a, int l, int r) {
    Stats stats;
    bool flag = false;
    for (int i = l; i < r; i++) {
        for (int j = r; j > i; j--) {
            if (a.at(j-1) > a.at(j)) {
                if (flag == false) flag = true;
                swap(a.at(j - 1), a.at(j));
                ++stats.swaps_;
            }
            ++stats.compares_;
        }
        if (flag == false) break;
    }
    return stats;
}

int main()
{
    std::vector<int> v1{ 4, 8, 3, 8, 10, -1, 3, 20, 5 };

    std::vector<int> v1s = v1;
    std::cout << "sel " << selectionSort(v1s, 0, v1s.size() - 1);

    std::vector<int> v1b = v1;
    std::cout << ", bub " << bubbleSort(v1b, 0, v1b.size() - 1) << '\n';
    assert(v1s == v1b);
    // always a good idea to check the code's doing what you expect...
    for (int i : v1s) std::cout << i << ' ';
       std::cout << '\n';
}

输出：

sel { swaps 6, compares 36 }, bub { swaps 15, compares 36 }

-1 3 3 4 5 8 8 10 20

您可以在线观察/复制/分叉编辑/运行代码here。

是否有任何输入选择排序优于冒泡排序？

2 个答案: