[已解决]冒泡排序，哪里错了

王鹿其

#include<iostream>
using namespace std;
int main()
{
        int arr[] = { 7,8,9,4,5,6,3,2,1, };
        for (int i = 0; i <= 8; i++)
        {
                cout << arr[i] << " ";
        }
       
        for (int j = 0; j <= 8; j++)
        {
                for (int k = 0; k <= 9 - k - 1; j++)
                {
                        if (arr[k] > arr[k + 1])
                        {
                                int temp = arr[k];
                                arr[k] = arr[k + 1];
                                arr[k + 1] = temp;
                        }
                }
                for (int j = 0;j <= 8;j++)
                {
                        cout << arr[j] << " ";
                }
        }
        return 0;
}

最佳答案

月排行榜 / 总排行榜

isdkz

2023-10-16 19:18:22

这段代码存在两个问题：

1. 内部循环的变量应该是k而不是j。因为这个循环的目的是将最大的数放到数组的最后一个位置，所以应该从第一个数开始比较，一直到倒数第二个数，即数组长度减一。

2. 外部循环的变量j每次增加1，但内部循环中的k的范围是在缩小的，应该改成k <= 9 - j - 1。

下面是修改后的代码：

1. #include<iostream>
   
2. using namespace std;
   
3. int main()
   
4. {
   
5.     int arr[] = { 7,8,9,4,5,6,3,2,1, };
   
6.     for (int i = 0; i <= 8; i++)
   
7.     {
   
8.         cout << arr[ i] << " ";
   
9.     }
   
10. 
    
11.     for (int j = 0; j <= 8; j++)
    
12.     {
    
13.         for (int k = 0; k <= 9 - j - 1; k++)
    
14.         {
    
15.             if (arr[k] > arr[k + 1])
    
16.             {
    
17.                 int temp = arr[k];
    
18.                 arr[k] = arr[k + 1];
    
19.                 arr[k + 1] = temp;
    
20.             }
    
21.         }
    
22.     }
    
23. 
    
24.     for (int j = 0;j <= 8;j++)
    
25.     {
    
26.         cout << arr[j] << " ";
    
27.     }
    
28.     return 0;
    
29. }
    

复制代码

希望能够帮到你。

跳转到最佳答案楼层

isdkz

这段代码存在两个问题：

1. 内部循环的变量应该是k而不是j。因为这个循环的目的是将最大的数放到数组的最后一个位置，所以应该从第一个数开始比较，一直到倒数第二个数，即数组长度减一。

2. 外部循环的变量j每次增加1，但内部循环中的k的范围是在缩小的，应该改成k <= 9 - j - 1。

下面是修改后的代码：

1. #include<iostream>
   
2. using namespace std;
   
3. int main()
   
4. {
   
5.     int arr[] = { 7,8,9,4,5,6,3,2,1, };
   
6.     for (int i = 0; i <= 8; i++)
   
7.     {
   
8.         cout << arr[ i] << " ";
   
9.     }
   
10. 
    
11.     for (int j = 0; j <= 8; j++)
    
12.     {
    
13.         for (int k = 0; k <= 9 - j - 1; k++)
    
14.         {
    
15.             if (arr[k] > arr[k + 1])
    
16.             {
    
17.                 int temp = arr[k];
    
18.                 arr[k] = arr[k + 1];
    
19.                 arr[k + 1] = temp;
    
20.             }
    
21.         }
    
22.     }
    
23. 
    
24.     for (int j = 0;j <= 8;j++)
    
25.     {
    
26.         cout << arr[j] << " ";
    
27.     }
    
28.     return 0;
    
29. }
    

复制代码

希望能够帮到你。

陶远航

你的冒泡排序代码中存在一些错误。以下是修正后的代码：

1. #include<iostream>
   
2. using namespace std;
   
3. int main()
   
4. {
   
5.         int arr[] = { 7,8,9,4,5,6,3,2,1 };
   
6.         int n = sizeof(arr) / sizeof(arr[0]); // 计算数组长度
   
7. 
   
8.         for (int i = 0; i < n; i++)
   
9.         {
   
10.                 cout << arr[ i] << " ";
    
11.         }
    
12.         cout << endl;
    
13. 
    
14.         for (int i = 0; i < n-1; i++)
    
15.         {
    
16.                 for (int j = 0; j < n - i - 1; j++)
    
17.                 {
    
18.                         if (arr[j] > arr[j + 1])
    
19.                         {
    
20.                             int temp = arr[j];
    
21.                             arr[j] = arr[j + 1];
    
22.                             arr[j + 1] = temp;
    
23.                         }
    
24.                 }
    
25.                 for (int k = 0; k < n; k++)
    
26.                 {
    
27.                         cout << arr[k] << " ";
    
28.                 }
    
29.                 cout << endl;
    
30.         }
    
31.         return 0;
    
32. }
    

复制代码

这里的错误和修正包括：

1. 在内层循环中，你应该增加 j 而不是 k。你的代码中写的是 j++，这是错误的，应该是 k++。

2. 在内层循环的条件中，你应该检查 k < n - i - 1，而不是 k <= 9 - k - 1。你的代码中的条件会导致数组越界。

3. 在打印排序后的数组时，你应该在每一轮排序后打印，而不是在每一次交换后打印。

4. 你的数组长度是硬编码的，这不是一个好的做法。你应该计算数组的长度，这样如果数组的长度改变，你的代码仍然可以正确工作。

以上就是你的代码中的错误和修正方法。
请注意，本回答来自GPT-4
如果问题已经解决，请设置最佳答案

Mike_python小

你好，这段代码中有两个错误。

第一个错误是在冒泡排序的内层循环中，变量名应该是 k 而不是 j，因为此处是对数组中相邻的两个元素进行比较与交换，而非遍历整个数组。此处的循环条件应该是 k < 9 - j，而非 9 - k - 1，因为每次循环可以确定一个最大值，不需要再次比较已经排好序的元素。

第二个错误是在第二个 for 循环中，又嵌套了一个 for 循环，而且变量名也是 j，这会和外层循环中的变量名 j 产生冲突。此处的输出操作应该放在外层循环中，这样每次交换都可以看到当前的排序结果。

修改后的代码如下：

1. ++
2. #include<iostream>
3. using namespace std;
5. int main()
6. {
7.     int arr[] = {7, 8, 9, 4, 5, 6, 3, 2, 1};
8.     for (int i = 0; i <= 8; i++) {
9.         cout << arr[i] << " ";
10.     }
11.     cout << endl;
13.     for (int j = 0; j < 8; j++) {
14.         for (int k = 0; k < 9 - j; k++) {
15.             if (arr[k] > arr[k + 1]) {
16.                 int temp = arr[k];
17.                 arr[k] = arr[k + 1];
18.                 arr[k + 1] = temp;
19.             }
20.         }
21.         for (int k = 0; k <= 8; k++) {
22.             cout << arr[k] << " ";
23.         }
24.         cout << endl;
25.     }
27.     return 0;
28. }

复制代码

输出结果为：

[/code]
7 8 9 4 5 6 3 2 1
7 8 4 5 6 3 2 1 9
7 4 5 6 3 2 1 8 9
4 5 6 3 2 1 7 8 9
4 5 3 2 1 6 7 8 9
4 3 2 1 5 6 7 8 9
3 2 1 4 5 6 7 8 9
2 1 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
[/code]

其中，外层循环控制排序的趟数，内层循环控制每一趟中相邻元素的比较与交换，每执行完一轮冒泡操作就输出当前的排序结果。

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

琅琊王朝

您的代码中存在一些错误，以下是对您代码的修正和解释。

在第二个for循环中，您使用了变量j，但是这个变量在这个循环中并没有用到。我猜您可能是想继续打印数组的元素，但是这个j在这个循环中并没有起到这个作用。
在内部的for循环中，您将变量k的最大值设为9-k-1。这会导致数组越界，因为当k等于8时，9-k-1等于-8，这将导致数组arr[k]和arr[k + 1]访问失败。这个循环应该放到外部循环中。
在内部的if语句中，您想要比较相邻的两个元素，但是在循环中您用了变量j而不是k。在冒泡排序中，您需要比较的是相邻的元素，所以这里应该是arr[k]和arr[k + 1]。
交换的语句似乎有问题，temp变量并没有被使用。交换两个变量的值应该是这样的：a = a + b; b = a - b; a = a - b;

以下是修正后的代码：

1. #include<iostream>
   
2. using namespace std;
   
3. 
   
4. void bubbleSort(int arr[], int n) {
   
5.     for (int k = 0; k < n - 1; k++) {
   
6.         for (int j = 0; j < n - k - 1; j++) {
   
7.             if (arr[j] > arr[j + 1]) {
   
8.                 int temp = arr[j];
   
9.                 arr[j] = arr[j + 1];
   
10.                 arr[j + 1] = temp;
    
11.             }
    
12.         }
    
13.     }
    
14. }
    
15. 
    
16. int main() {
    
17.     int arr[] = { 7, 8, 9, 4, 5, 6, 3, 2, 1 };
    
18.     int n = sizeof(arr) / sizeof(arr[0]);
    
19.     bubbleSort(arr, n);
    
20.     for (int i = 0; i < n; i++) {
    
21.         cout << arr[i] << " ";
    
22.     }
    
23.     cout << endl;
    
24.     return 0;
    
25. }

复制代码

以上代码首先定义了一个bubbleSort函数来执行冒泡排序，然后在main函数中对数组进行排序并打印排序后的数组。