11-C++算法01-枚举排序

最新推荐文章于 2024-01-13 15:00:37 发布

逸峰轻云

最新推荐文章于 2024-01-13 15:00:37 发布

阅读量2k

点赞数 2

文章标签：算法 c++ 排序算法

本文链接：https://blog.csdn.net/mingfeng4923/article/details/131485822

版权

📖 C++算法

在编程中，算法是解决问题的一系列步骤或规则。在C++中，提供了丰富的算法库，可以方便地进行各种常见的算法操作。本篇学习笔记将介绍一些常见的排序算法，帮助你理解和应用这些算法。

🚀 枚举

🎯 什么是枚举

枚举（暴力）是一种常见的算法解题方法，也称为穷举法。它的核心思想是通过遍历所有可能的情况，逐一检查每个情况是否满足问题的要求，从而找到问题的解决方案。

在枚举算法中，通过遍历问题的所有可能解，一一进行验证，直到找到符合要求的解，或者遍历完所有可能的解。这种方法有时被称为"暴力枚举"，因为它不借助其他高效算法，而是直接尝试所有可能的情况。

枚举的核心思想是穷举和验证。它通过枚举所有可能的解决方案，逐个验证它们是否满足问题的限制条件。这种方法的优势在于简单直观，适用于一些规模较小的问题，或者是对解决方案的完整性要求较高的情况。

然而，枚举算法的一个主要缺点是它的时间复杂度通常较高，特别是在问题规模较大的情况下。由于要遍历所有可能的情况，枚举算法可能需要消耗大量的时间和计算资源。因此，在实际应用中，我们需要根据问题的规模和要求来选择合适的算法，以提高效率和降低计算成本。

总而言之，枚举（暴力）是一种通过遍历所有可能情况，并逐一验证其有效性的算法方法。它的核心思想是穷举和验证，适用于一些规模较小或对解决方案完整性要求较高的问题。然而，由于其时间复杂度较高，需要在实际应用中谨慎选择使用。它通常适用于问题的解空间较小或问题规模较小的情况。

🎯 枚举案例

让我们以一个简单的例子来说明枚举算法的应用。假设我们要从1到100中找出能被3整除且能被5整除的数字，可以使用枚举算法来解决。

#include <iostream>
using namespace std;

int main() {
    for (int i = 1; i <= 100; i++) {
        if (i % 3 == 0 && i % 5 == 0) {
            cout << i << " ";
        }
    }

    return 0;
}

在上述示例中，我们使用循环遍历从1到100的数字，然后通过判断是否能被3整除且能被5整除，来找出满足条件的数字并输出。

🔍 排序

排序是一种常见的算法操作，用于将一组数据按照特定的顺序进行排列。在实际开发中，常见的排序算法有冒泡排序、选择排序、插入排序、桶排序等。让我们逐一介绍这些排序算法及其练习题。

✨ 冒泡排序

冒泡排序是一种简单直观的排序算法，它重复地遍历待排序序列，每次比较相邻的两个元素，如果顺序错误就交换位置，直到整个序列有序为止。

#include <iostream>
using namespace std;

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换位置
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[] = {5, 2, 8, 1, 9};
    int n = sizeof(arr) / sizeof(arr[0]);

    bubbleSort(arr, n);

    cout << "Sorted array: ";
    for (int i = 0; i <

 n; i++) {
        cout << arr[i] << " ";
    }

    return 0;
}

在上述示例中，我们使用冒泡排序算法对数组进行排序，并输出排序后的结果。

冒泡排序练习题

练习题：请编写一个程序，使用冒泡排序算法对用户输入的一组整数进行排序。

#include <iostream>
using namespace std;

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换位置
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int n;
    cout << "Enter the number of elements: ";
    cin >> n;

    int arr[n];
    cout << "Enter the elements: ";
    for (int i = 0; i < n; i++) {
        cin >> arr[i];
    }

    bubbleSort(arr, n);

    cout << "Sorted array: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }

    return 0;
}

在上述练习题中，我们首先让用户输入一组整数，然后使用冒泡排序算法对其进行排序，并输出排序后的结果。

✨ 选择排序

选择排序是一种简单直观的排序算法，它将待排序序列分为已排序和未排序两部分，每次从未排序部分选择最小的元素，放到已排序部分的末尾。

#include <iostream>
using namespace std;

void selectionSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        // 交换位置
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

int main() {
    int arr[] = {5, 2, 8, 1, 9};
    int n = sizeof(arr) / sizeof(arr[0]);

    selectionSort(arr, n);

    cout << "Sorted array: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }

    return 0;
}

在上述示例中，我们使用选择排序算法对数组进行排序，并输出排序后的结果。

选择排序练习题

练习题：请编写一个程序，使用选择排序算法对用户输入的一组整数进行排序。

#include <iostream>
using namespace std;

void selectionSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int minIndex = i;
        for (int j

 = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        // 交换位置
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

int main() {
    int n;
    cout << "Enter the number of elements: ";
    cin >> n;

    int arr[n];
    cout << "Enter the elements: ";
    for (int i = 0; i < n; i++) {
        cin >> arr[i];
    }

    selectionSort(arr, n);

    cout << "Sorted array: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }

    return 0;
}

在上述练习题中，我们首先让用户输入一组整数，然后使用选择排序算法对其进行排序，并输出排序后的结果。

✨ 插入排序

插入排序是一种简单直观的排序算法，它将待排序序列分为已排序和未排序两部分，每次从未排序部分选择一个元素，插入到已排序部分的合适位置。

#include <iostream>
using namespace std;

void insertionSort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

int main() {
    int arr[] = {5, 2, 8, 1, 9};
    int n = sizeof(arr) / sizeof(arr[0]);

    insertionSort(arr, n);

    cout << "Sorted array: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }

    return 0;
}

在上述示例中，我们使用插入排序算法对数组进行排序，并输出排序后的结果。

插入排序练习题

练习题：请编写一个程序，使用插入排序算法对用户输入的一组整数进行排序。

#include <iostream>
using namespace std;

void insertionSort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

int main() {
    int n;
    cout << "Enter the number of elements: ";
    cin >> n;

    int arr[n];
    cout << "Enter the elements: ";
    for (int i = 0; i < n; i++) {
        cin >> arr[i];
    }

    insertionSort(arr, n);

    cout << "Sorted array: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }

    return 0;
}

在上述练习题中，我们首先让用户输入一组整数，然后使用插入排序算法对其进行排序，并输出排序后的结果。

✨ 桶排序

桶排序是一种分配排序算法，它通过将元素分配到不同的桶中，然后对每个桶中的元素进行排序，最后将所有桶中的元素合并得到有序序列。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

void bucketSort(float arr[], int n) {
    vector<float> buckets[n];
    for (int i = 0; i < n; i++) {
        int bucketIndex = n * arr[i];
        buckets[bucketIndex].push_back(arr[i]);
    }
    for (int i = 0; i < n; i++) {
        sort(buckets[i].begin(), buckets[i].end());
    }
    int index = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < buckets[i].size(); j++) {
            arr[index++] = buckets[i][j];
        }
    }
}

int main() {
    float arr[] = {0.12, 0.83, 0.45, 0.21, 0.67};
    int n = sizeof(arr) / sizeof(arr[0]);

    bucketSort(arr, n);

    cout << "Sorted array: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }

    return 0;
}

在上述示例中，我们使用桶排序算法对浮点数数组进行排序，并输出排序后的结果。

桶排序练习题

练习题：请编写一个程序，使用桶排序算法对用户输入的一组浮点数进行排序。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

void bucketSort(float arr[], int n) {
    vector<float> buckets[n];
    for (int i = 0; i < n; i++) {
        int bucketIndex = n * arr[i];
        buckets[bucketIndex].push_back(arr[i]);
    }
    for (int i = 0; i < n; i++) {
        sort(buckets[i].begin(), buckets[i].end());
    }
    int index = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < buckets[i].size(); j++) {
            arr[index++] = buckets[i][j];
        }
    }
}

int main() {
    int n;
    cout << "Enter the number of elements: ";
    cin >> n;

    float arr[n];
    cout << "Enter the elements: ";
    for (int i = 0; i < n; i++) {
        cin >> arr[i];
    }

    bucketSort(arr, n);

    cout << "Sorted array: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }

    return 0;
}

在上述练习题中，我们首先让用户输入一组浮点数，然后使用桶排序算法对其进行排序，并输出排序后的结果。

📖总结

在本节中，我们介绍了枚举算法和常见的排序算法，包括冒泡排序、选择排序、插入排序和桶排序。这些算法是基础的排序算法，掌握它们对于理解和学习更高级的排序算法是非常重要的。

枚举算法是一种穷举所有可能的方法，通过遍历所有可能的解空间来解决问题。冒泡排序是一种简单直观的排序算法，通过相邻元素的比较和交换来将最大的元素逐步交换到数组的末尾。选择排序是一种每次选择最小元素的排序算法，通过不断选择未排序部分的最小元素并放到已排序部分的末尾来完成排序。插入排序是一种通过构建有序部分并逐步将元素插入到合适位置的排序算法。桶排序是一种将元素分配到不同桶中并对每个桶中的元素进行排序的算法，最后将所有桶中的元素合并得到有序序列。

通过对每种排序算法的原理、示例代码和练习题的学习和实践，我们可以更好地理解和掌握这些算法。排序算法在实际开发中有广泛的应用，对于处理数据和优化算法性能非常重要。掌握不同的排序算法有助于我们在不同场景下选择合适的算法，并能够对算法进行分析和优化。

希望本节的学习能够帮助你更好地理解和掌握C++中的枚举算法和排序算法。继续加油，继续学习，提升编程技能！🚀

⭐️希望本篇文章对你有所帮助。

⭐️如果你有任何问题或疑惑，请随时向提问。

⭐️感谢阅读！