[已解决]这个冒泡排序为什么错了

黎子卿

#include <iostream>
using namespace std;
#include <vector>
vector<int> pai(vector<int> nums)
{
        vector<int> res;
        if (nums.size() == 1)
        {
                res.push_back(nums[0]);
                return res;
        }
        int i = 0;
        while (i < nums.size() - 1)
        {
                if (nums[i + 1] < nums[i])
                {
                        int c = nums[i + 1];
                        nums[i + 1] = nums[i];
                        nums[i] = c;
                }
                i = i + 1;
        }
        vector<int> new1(nums.begin(), nums.end() - 1);
        res.push_back(nums[nums.size() - 1]);
        return pai(new1);
}
int main()
{
        int n;
        cin >> n;
        int num;
        vector<int> nums1;
        for (int i = 1; i <= n; i++)
        {
                cin >> num;
                nums1.push_back(num);
        }
        nums1 = pai(nums1);
        for (int i = nums1.size()-1; i >=0; i--)
        {
                cout << nums1[i] << " ";
        }
        return 0;
}

最佳答案

月排行榜 / 总排行榜

Mike_python小

2023-11-5 20:53:41

这段代码实现了使用冒泡排序对输入的一组整数进行排序。然而，代码中存在一个错误导致排序结果不正确。

错误在于冒泡排序的实现部分。在当前的实现中，只进行了一次比较和交换操作，并没有进行多轮的比较和交换来正确排序。

要修复这个错误，需要对冒泡排序的实现进行修改。以下是修复后的代码：

2. #include <iostream>
3. #include <vector>
4. using namespace std;
6. vector<int> bubbleSort(vector<int> nums)
7. {
8.     int n = nums.size();
9.     for (int i = 0; i < n - 1; i++)
10.     {
11.         for (int j = 0; j < n - i - 1; j++)
12.         {
13.             if (nums[j] > nums[j + 1])
14.             {
15.                 int temp = nums[j];
16.                 nums[j] = nums[j + 1];
17.                 nums[j + 1] = temp;
18.             }
19.         }
20.     }
21.     return nums;
22. }
24. int main()
25. {
26.     int n;
27.     cin >> n;
28.     vector<int> nums(n);
29.     for (int i = 0; i < n; i++)
30.     {
31.         cin >> nums[i];
32.     }
34.     nums = bubbleSort(nums);
36.     for (int i = 0; i < n; i++)
37.     {
38.         cout << nums[i] << " ";
39.     }
41.     return 0;
42. }

复制代码

修复后的代码中，我们使用了两层嵌套的循环。外层循环控制排序的轮数，内层循环执行相邻元素的比较和交换操作。通过多次循环，每次都将最大元素移动到数组末尾，逐步实现排序。

希望以上回答对您有所帮助。如果还有其他问题，请随时提问。

球一个最佳答案谢谢啦！这对我非常重要！

跳转到最佳答案楼层

isdkz

问题出在冒泡排序的实现上。冒泡排序的基本思想是通过相邻元素的比较和交换来实现排序，但是你的代码中只进行了一次比较和交换，而没有进行多次循环来完整地进行排序。

在你的代码中，只有一个while循环，循环条件是i < nums.size() - 1，即只进行一轮循环。在这一轮循环中，只进行了一次比较和交换操作，即如果nums[i + 1] < nums[ i]，则交换两个元素的位置。然后更新i的值，继续下一轮循环。

然而，冒泡排序需要进行多次循环，每次循环都将最大的元素冒泡到最后的位置。你的代码中缺少了这个多次循环的部分，导致排序结果是错误的。

为了修正这个问题，你需要在while循环外再套一个for循环，这个for循环控制多次循环的次数。每次循环中，都要进行一轮完整的冒泡排序操作。

修正后的代码如下：

1. vector<int> pai(vector<int> nums)
   
2. {
   
3.     vector<int> res;
   
4.     if (nums.size() == 1)
   
5.     {
   
6.         res.push_back(nums[0]);
   
7.         return res;
   
8.     }
   
9.     for (int j = 0; j < nums.size() - 1; j++) // 多次循环
   
10.     {
    
11.         int i = 0;
    
12.         while (i < nums.size() - 1)
    
13.         {
    
14.             if (nums[i + 1] < nums[ i])
    
15.             {
    
16.                 int c = nums[i + 1];
    
17.                 nums[i + 1] = nums[ i];
    
18.                 nums[ i] = c;
    
19.             }
    
20.             i = i + 1;
    
21.         }
    
22.     }
    
23.     vector<int> new1(nums.begin(), nums.end() - 1);
    
24.     res.push_back(nums[nums.size() - 1]);
    
25.     return pai(new1);
    
26. }
    

复制代码

修正后的代码中，在while循环外套了一个for循环，控制多次循环的次数。每次循环中，都会进行一轮完整的冒泡排序操作。这样就可以得到正确的排序结果。

Mike_python小

这段代码实现了使用冒泡排序对输入的一组整数进行排序。然而，代码中存在一个错误导致排序结果不正确。

错误在于冒泡排序的实现部分。在当前的实现中，只进行了一次比较和交换操作，并没有进行多轮的比较和交换来正确排序。

要修复这个错误，需要对冒泡排序的实现进行修改。以下是修复后的代码：

2. #include <iostream>
3. #include <vector>
4. using namespace std;
6. vector<int> bubbleSort(vector<int> nums)
7. {
8.     int n = nums.size();
9.     for (int i = 0; i < n - 1; i++)
10.     {
11.         for (int j = 0; j < n - i - 1; j++)
12.         {
13.             if (nums[j] > nums[j + 1])
14.             {
15.                 int temp = nums[j];
16.                 nums[j] = nums[j + 1];
17.                 nums[j + 1] = temp;
18.             }
19.         }
20.     }
21.     return nums;
22. }
24. int main()
25. {
26.     int n;
27.     cin >> n;
28.     vector<int> nums(n);
29.     for (int i = 0; i < n; i++)
30.     {
31.         cin >> nums[i];
32.     }
34.     nums = bubbleSort(nums);
36.     for (int i = 0; i < n; i++)
37.     {
38.         cout << nums[i] << " ";
39.     }
41.     return 0;
42. }

复制代码

修复后的代码中，我们使用了两层嵌套的循环。外层循环控制排序的轮数，内层循环执行相邻元素的比较和交换操作。通过多次循环，每次都将最大元素移动到数组末尾，逐步实现排序。

希望以上回答对您有所帮助。如果还有其他问题，请随时提问。

球一个最佳答案谢谢啦！这对我非常重要！