我有关于冒泡排序法还是有很多疑问的，恳求大佬们帮我解决

学c的萌新

#include<stdio.h>
#include<stdlib.h>
#define _CRT_SECURE_NO_WARNINGS
        //论数和次数，还有元素个数之间的关系就是，元素数字为sizeof(arr)/sizeof(arr[0]);,论数是元素个数-1；次数是元素个数-对比论数-1
void test01()
{
        int arr[] = { 4,2,1,3,5,7,8,6,0 };
        for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
        {
                for (int j = 0; sizeof(arr) / sizeof(arr[0]) - i - 1; j++)
                {
                        if (arr[j] > arr[j + 1])
                        {
                                int tamp = arr[j];
                                arr[j + 1] = arr[j];
                                arr[j + 1] = tamp;
                        }
                }
        }
        for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
        {
                printf("%d", arr[i]);
        }
        printf("\n");
}


void main()
{
        test01();

        system("parse");
        return 0;

}
大佬们，首先这个程序无法运行说是出现了一些错误，然后，我还有一些疑问，就是关于冒泡排序法的，我感觉自己这段时间学习的一点也不扎实，而且还总是忘记，关于这里面的一些逻辑问题我还是很迷糊，唉，我是不是应该补充一点数学的知识，我感觉自己的逻辑不通

陶远航

首先，让我们来解决你提供的代码中的问题。在你的代码中，有几个地方需要进行修改：

1. 在内部循环的判断条件中，你需要比较j和sizeof(arr) / sizeof(arr[0]) - i - 1的大小关系，并将结果作为条件。你可以修改为 j < sizeof(arr) / sizeof(arr[0]) - i - 1。

2. 在交换元素的代码中，你需要将arr[j + 1] = arr[j];修改为arr[j] = arr[j + 1];，因为你希望交换的是相邻的两个元素。

此外，你还需要注意一些细节问题：

3. 将void main()改为int main()，并将return 0;改为return 0;。main()函数应该返回一个int类型的值。

4. 将system("parse");改为system("pause");，以便在程序执行完后暂停输出结果。

修改后的代码如下所示：

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. 
   
4. #define _CRT_SECURE_NO_WARNINGS
   
5. 
   
6. void test01() {
   
7.     int arr[] = { 4,2,1,3,5,7,8,6,0 };
   
8. 
   
9.     for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
   
10.         for (int j = 0; j < sizeof(arr) / sizeof(arr[0]) - i - 1; j++) {
    
11.             if (arr[j] > arr[j + 1]) {
    
12.                 int temp = arr[j];
    
13.                 arr[j] = arr[j + 1];
    
14.                 arr[j + 1] = temp;
    
15.             }
    
16.         }
    
17.     }
    
18. 
    
19.     for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
    
20.         printf("%d ", arr[ i]);
    
21.     }
    
22.     printf("\n");
    
23. }
    
24. 
    
25. int main() {
    
26.     test01();
    
27.     system("pause");
    
28.     return 0;
    
29. }
    

复制代码

至于你对冒泡排序算法的疑问，我会尽量解答：

冒泡排序是一种简单的排序算法，它通过多次比较和交换相邻元素的方式，将较大的元素逐步向右侧移动，从而达到排序的目的。

冒泡排序的基本思路如下：

1. 从第一个元素开始，依次比较相邻的两个元素。如果前一个元素大于后一个元素，就交换它们的位置，使较大的元素向右移动。

2. 经过一轮比较之后，最后一个元素一定是当前未排序部分的最大值。

3. 对除最后一个元素外的剩余元素，重复步骤1和2，直到所有元素都被排序。

根据冒泡排序的性质，每经过一轮比较，未排序部分的最大值就会浮到最右侧，因此内层循环的次数逐渐减少。外层循环控制进行多少轮比较，最多需要进行n-1轮比较（n为元素个数）。

关于你提到的数学知识，对于理解冒泡排序并不是必需的。冒泡排序主要涉及到算法和编程的概念，而不是复杂的数学计算。重点是理解算法的思想和实现方式，并通过实际的代码练习来加深理解和记忆。

如果你对冒泡排序还有其他疑问，或者有其他需要解答的问题，请随时追问！
如果问题已经解决，请设置最佳答案

isdkz

首先，关于你的代码无法运行的问题，我注意到你在交换元素时出现了一个错误。在冒泡排序中，你需要将较大的元素向后移动，而不是将较小的元素向前移动。所以，在交换元素时，你需要将 arr[j] 赋值给 tamp ，然后将 tamp 赋值给 arr[j+1] ，而不是将 arr[j+1] 赋值给 arr[j+1] 。这是你修复代码的地方：

1. if (arr[j] > arr[j + 1])
   
2. {
   
3.     int tamp = arr[j];
   
4.     arr[j] = arr[j + 1]; // 将较大的元素向后移动
   
5.     arr[j + 1] = tamp;
   
6. }
   

复制代码

另外，你在内部循环的条件中出现了一个错误。你需要将 sizeof(arr) / sizeof(arr[0]) - i - 1 作为循环的终止条件，而不是仅仅写 sizeof(arr) / sizeof(arr[0]) - i - 1 。这是你修复代码的地方：

1. for (int j = 0; j < sizeof(arr) / sizeof(arr[0]) - i - 1; j++) // 添加 "<" 符号
   
2. {
   
3.     // 冒泡排序的代码
   
4. }
   

复制代码

关于你对冒泡排序算法的疑问，冒泡排序是一种简单但低效的排序算法。它的基本思想是通过相邻元素的比较和交换来将最大（或最小）的元素逐渐“浮”到数组的末尾。这个过程类似于冒泡泡上升到表面的过程，因此得名冒泡排序。

冒泡排序的核心是双重循环。外层循环控制论数（轮数），内层循环控制次数（每轮需要比较的次数）。每一轮内层循环都会将当前未排序部分中的最大元素“冒泡”到最后。所以，内层循环的终止条件是元素个数减去当前论数减一。

冒泡排序的时间复杂度是O(n^2)，其中n是数组的大小。由于它需要进行多次比较和交换，所以在大规模数据排序时效率较低。如果你想提高排序算法的效率，可以考虑使用其他更高效的排序算法，如快速排序或归并排序。

关于你提到的数学知识，冒泡排序算法并不需要太多的数学知识。它更多地涉及到对数组和循环的理解。如果你对逻辑有困惑，建议你多练习编写简单的代码，加深对基本概念和语法的理解。同时，阅读相关的教材和学习资源也是提高编程能力的好方法。

额外减小

其实基础问题还是比较多的。

额外减小

这种问题的话，建议先问ChatGPT(例如：c.binjie.fun)，然后再来论坛问。
问题解决：
1.swap方法错了。应为

1. . . .
   
2. int temp=arr[i];
   
3. arr[i]=arr[j];
   
4. arr[j]=temp;
   
5. . . .

复制代码

对应最内层括号里的内容。这个要注意，顺序不能搞反了。

2.冒泡排序我好像没见过像你这样排的，我一般是这两个循环嵌套。

1.         for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
   
2.         {
   
3.                 for (int j = i+1;j< sizeof(arr) / sizeof(arr[0]); j++)
   
4.                 {
   
5.                         if (arr[i] > arr[j])
   
6.                         {
   
7.                                 int temp = arr[j];
   
8.                                 arr[j] = arr[i];
   
9.                                 arr[i] = temp;
   
10.                         }
    
11.                 }
    
12.         }

复制代码

3.system("pause")
4.

1. int main()
   
2. 而不是
   
3. void main()

复制代码

void main()在现在的编译器会报错。

额外减小

对于你的代码修改了一下
修改的地方写在注释里面

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #define _CRT_SECURE_NO_WARNINGS
   
4.         //论数和次数，还有元素个数之间的关系就是，元素数字为sizeof(arr)/sizeof(arr[0]);,论数是元素个数-1；次数是元素个数-对比论数-1
   
5. void test01()
   
6. {
   
7.         int arr[] = { 4,2,1,3,5,7,8,6,0 };
   
8.         for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
   
9.         {
   
10.                 for (int j = 0; sizeof(arr) / sizeof(arr[0]) - j - 1; j++) //origin:    ...for (int j = 0; sizeof(arr) / sizeof(arr[0]) - i - 1; j++)
    
11.                 {
    
12.                         if (arr[j] > arr[j + 1])
    
13.                         {
    
14.                                 int tamp = arr[j];//
    
15.                                 arr[j] = arr[j+1];//origin:   arr[j+1]=arr[j]
    
16.                                 arr[j + 1] = tamp;//
    
17.                         }
    
18.                 }
    
19.         }
    
20.         for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    
21.         {
    
22.                 printf("%d", arr[i]);
    
23.         }
    
24.         printf("\n");
    
25. }
    
26. 
    
27. 
    
28. int main()//origin:    void main()
    
29. {
    
30.         test01();
    
31. 
    
32.         system("pause");  //origin:    "parse"
    
33.         return 0;
    
34. 
    
35. }

复制代码