cyuyajishu

#include <stdio.h>
void BubbleSort(int* nums,int n);
int main()
{
    int nums[10000],n=20000,i;
    for(i=0;i<20000;i++)
    {
        nums[i]=30000-i;
    }
    BubbleSort(nums,n);
}
void BubbleSort(int* nums,int n)
{
    int i,j;
    for(i=0;i<n-1;i++)
    {
        for(j=0;j<n-i-1;j++)
        {
            if(nums[j]>nums[j+1])
            {
                int temp=nums[j];
                nums[j]=nums[j+1];
                nums[j+1]=temp;
            }
        }

    }
}
#include <stdio.h>
void BubbleSort(int* nums,int n);
int main()
{
    int nums[10000],n=20000,i;
    for(i=0;i<20000;i++)
    {
        nums[i]=rand()%20000+1;
    }
    BubbleSort(nums,n);
}
void BubbleSort(int* nums,int n)
{
    int i,j;
    for(i=0;i<n-1;i++)
    {
        for(j=0;j<n-i-1;j++)
        {
            if(nums[j]>nums[j+1])
            {
                int temp=nums[j];
                nums[j]=nums[j+1];
                nums[j+1]=temp;
            }
        }

    }
}
#include <stdio.h>
void BubbleSort(int* nums,int n);
int main()
{
    int nums[10000],n=20000,i;
    for(i=0;i<20000;i++)
    {
        nums[i]=rand()%20000+1;
    }
    BubbleSort(nums,n);
}
void BubbleSort(int* nums,int n)
{
    int i,j;
    for(i=0;i<n-1;i++)
    {
        for(j=0;j<n-i-1;j++)
        {
            if(nums[j]>nums[j+1])
            {
                int temp=nums[j];
                nums[j]=nums[j+1];
                nums[j+1]=temp;
            }
        }

    }
}

你想问什么，你的程序重复了3次，后面2个删除掉
另外你的程序缺少输出，所以排序虽然完成了，但是你也不知道

【以下回答由 GPT 生成】

冒泡排序是一种简单的排序算法，它重复地交换相邻的元素，将较大（或较小）的元素逐渐“冒泡”到数组的一端。

以下是使用C语言编写冒泡排序算法的步骤：

1. 首先，在代码中定义一个BubbleSort函数，接受一个整数数组和数组的大小作为参数。声明该函数的原型如下：

void BubbleSort(int* nums, int n);

1. 在代码中定义main函数，生成一个包含20000个元素的整数数组nums，并将每个元素初始化为1到20000之间的随机数。

2. 在main函数中调用BubbleSort函数，将nums数组和数组的大小n作为参数传递给BubbleSort函数。

3. 在BubbleSort函数中，使用两层嵌套循环来遍历数组。外层循环控制比较的轮数，内层循环控制每一轮的比较次数。

4. 在内层循环中，比较相邻的两个元素。如果前一个元素大于后一个元素，则交换它们的位置。

5. 继续进行下一轮的比较，直到所有元素都按照从小到大（或从大到小）的顺序排列。

6. 最终，BubbleSort函数结束执行后，nums数组中的元素将按照从小到大的顺序排列。

该程序的工作原理如下：

1. 在main函数中，生成一个包含20000个元素的整数数组nums，并将每个元素初始化为1到20000之间的随机数。

2. 在main函数中调用BubbleSort函数，将nums数组和数组的大小20000作为参数传递给BubbleSort函数。

3. 在BubbleSort函数中，通过两层嵌套循环来遍历数组。外层循环每次确定一个最大的元素，内层循环用于比较相邻的两个元素并进行交换。

4. 内层循环中，比较当前元素和后一个元素的值。如果当前元素大于后一个元素，则交换它们的位置。

5. 经过一轮的比较和交换后，最大的元素被冒泡到数组的最后。

6. 外层循环继续执行，每次确定一个最大的元素，并将其冒泡到数组的末尾。

7. 当外层循环执行完毕后，所有的元素都按照从小到大的顺序排列。

8. BubbleSort函数执行完毕后，返回到main函数。

注意，以上的冒泡排序算法是基于从小到大的排序，如果要实现从大到小的排序，只需将if语句中的判断条件改为nums[j]<nums[j+1]即可。