[已解决]关于’‘简单的排列算法表达式中换个符号，导致结果也不相同’‘的问题

kaishao

如图所示。为什么我两边同时用加法时，结果是正确的。
但是如果同时换成减法时，结果1这个数字的位置会出错？

题目：对打乱的1--20进行排列。

加法：
加法结果：

减法：
减法结果：

1. #include <stdio.h>
   
2. int main() {
   
3.         int a[20] = { 1,9,10,6,4,8,3,5,7,11,15,16,17,18,13,12,14,19,20,2};
   
4.         int c, i,e,q;
   
5.         for (i = 19; i > 0; i--) {
   
6.                 for (c = 19; c >0; c--) {
   
7.                         if (a[i] <a[c]) {
   
8.                                 e = a[i];
   
9.                                 a[i] = a[c];
   
10.                                 a[c] = e;
    
11.                                 continue;
    
12.                         }
    
13.                 }for (q = 0; q < 20; q++) {
    
14.                 printf("%d  ", a[q]);
    
15.                 }printf("\n");
    
16.         }
    
17.         return 0;
    
18. }

复制代码

还请大佬门帮我这个新手解答解答；
如果有其它算法，还请高抬贵手，发出来让小生学习学习，
谢谢！！！！

最佳答案

月排行榜 / 总排行榜

sfqxx

2023-7-6 07:26:00

根据你提供的代码，我看到你尝试使用冒泡排序算法对数组进行排序。冒泡排序是一种简单但效率较低的排序算法。

在你的加法代码中，你使用了两个嵌套的循环来比较和交换数组元素的位置，从而实现排序。同时，你使用两个指针i和c来迭代数组元素，并比较它们的值。

在你的减法代码中，你同样使用了冒泡排序算法，只不过你将迭代的方向从正向改为了反向。这个修改导致了排序结果不正确。

问题出在这一行代码上：

1. for (c = 19; c >0; c--)

复制代码

在这里，你将c的初始值设为19，而不是20。这导致你在排序时没有考虑到最后一个元素。应该将该行代码修改为：

1. for (c = 19; c >= 0; c--)

复制代码

此外，你还需要将外层循环的条件修改为`i >= 0`，以确保正确迭代整个数组。

另外，如果你对排序算法有兴趣，我可以介绍一些常用的高效排序算法，如快速排序。

我将详细介绍一种常用的排序算法——快速排序（Quick Sort)
快速排序是一种基于分治思想的排序算法，它的核心思想是选择一个基准元素，将数组划分为两个子数组，其中一个子数组的所有元素都小于等于基准元素，而另一个子数组的所有元素都大于基准元素。然后，对这两个子数组递归地应用同样的过程，直到每个子数组只包含一个元素为止。

下面是使用C++语言实现快速排序算法的示例代码：

1. #include <iostream>
   
2. using namespace std;
   
3. 
   
4. // 交换数组中两个元素的位置
   
5. void swap(int* a, int* b) {
   
6.     int temp = *a;
   
7.     *a = *b;
   
8.     *b = temp;
   
9. }
   
10. 
    
11. // 将基准元素放到合适的位置，并返回其索引
    
12. int partition(int arr[], int low, int high) {
    
13.     int pivot = arr[high]; // 选择最后一个元素作为基准
    
14.     int i = low - 1; // i表示已经处理完的元素的最右边界
    
15. 
    
16.     for (int j = low; j < high; j++) {
    
17.         if (arr[j] < pivot) {
    
18.             i++;
    
19.             swap(&arr[i], &arr[j]);
    
20.         }
    
21.     }
    
22. 
    
23.     swap(&arr[i + 1], &arr[high]);
    
24. 
    
25.     return (i + 1);
    
26. }
    
27. 
    
28. // 使用快速排序算法对数组进行排序
    
29. void quickSort(int arr[], int low, int high) {
    
30.     if (low < high) {
    
31.         int pivotIndex = partition(arr, low, high);
    
32.         quickSort(arr, low, pivotIndex - 1);
    
33.         quickSort(arr, pivotIndex + 1, high);
    
34.     }
    
35. }
    
36. 
    
37. int main() {
    
38.     int arr[] = { 10, 7, 8, 9, 1, 5 };
    
39.     int n = sizeof(arr) / sizeof(arr[0]);
    
40. 
    
41.     quickSort(arr, 0, n - 1);
    
42. 
    
43.     cout << "排序后的数组：";
    
44.     for (int i = 0; i < n; i++) {
    
45.         cout << arr[i] << " ";
    
46.     }
    
47. 
    
48.     return 0;
    
49. }

复制代码

以上代码演示了如何使用快速排序算法对整数数组进行排序。首先，我们定义了两个辅助函数，`swap()`用于交换数组中两个元素的位置，`partition()`用于将基准元素放到合适的位置并返回其索引。

然后，在`quickSort()`函数中，我们选择基准元素，并通过调用`partition()`函数将数组划分为两个子数组。然后，对这两个子数组递归地应用相同的过程，直到每个子数组只包含一个元素。

最后，在`main()`函数中，我们创建一个示例数组并调用`quickSort()`函数对它进行排序。排序完成后，我们输出排序后的数组。

快速排序算法的平均时间复杂度为O(nlogn)，其中n是数组的大小。它是一种高效的排序算法，并且在实践中被广泛使用。

求最佳答案

跳转到最佳答案楼层

陶远航

问题内容中提供了一段C语言的代码，用于对一个打乱顺序的数组进行排序。根据提供的代码和描述，我理解到你遇到了以下问题：当将排序算法中的比较运算符从小于号（<）改为大于号（>）时，排序结果出现错误。

通过分析代码，我发现代码中有两个地方需要进行修改：

1. 将第7行的 if (a < a[c]) 改为 if (a > a[c])。这是由于在排列算法中，如果当前索引i所对应的值a大于c所对应的值a[c]，则交换它们的位置，以确保较大的数后移。

2. 将第9行的 for (c = 19; c > 0; c--) 改为 for (c = 0; c < i; c++)。由于内层循环是冒泡排序的实现，每次循环要将当前最大值移到合适的位置，因此循环的起始位置应该是0而不是19。

修改后的代码如下所示：

1. c
2. #include <stdio.h>
4. int main() {
5.     int a[20] = { 1,9,10,6,4,8,3,5,7,11,15,16,17,18,13,12,14,19,20,2 };
6.     int c, i, e, q;
7.    
8.     for (i = 19; i > 0; i--) {
9.         for (c = 0; c < i; c++) {
10.             if (a[i] > a[c]) {
11.                 e = a[i];
12.                 a[i] = a[c];
13.                 a[c] = e;
14.                 continue;
15.             }
16.         }
17.         for (q = 0; q < 20; q++) {
18.             printf("%d  ", a[q]);
19.         }
20.         printf("\n");
21.     }
23.     return 0;
24. }

复制代码

这样修改后，代码将会按照从大到小的顺序对数组进行排序。希望能够解决你的问题！如果还有其他问题，请随时提问。

sfqxx

根据你提供的代码，我看到你尝试使用冒泡排序算法对数组进行排序。冒泡排序是一种简单但效率较低的排序算法。

在你的加法代码中，你使用了两个嵌套的循环来比较和交换数组元素的位置，从而实现排序。同时，你使用两个指针i和c来迭代数组元素，并比较它们的值。

在你的减法代码中，你同样使用了冒泡排序算法，只不过你将迭代的方向从正向改为了反向。这个修改导致了排序结果不正确。

问题出在这一行代码上：

1. for (c = 19; c >0; c--)

复制代码

在这里，你将c的初始值设为19，而不是20。这导致你在排序时没有考虑到最后一个元素。应该将该行代码修改为：

1. for (c = 19; c >= 0; c--)

复制代码

此外，你还需要将外层循环的条件修改为`i >= 0`，以确保正确迭代整个数组。

另外，如果你对排序算法有兴趣，我可以介绍一些常用的高效排序算法，如快速排序。

我将详细介绍一种常用的排序算法——快速排序（Quick Sort)
快速排序是一种基于分治思想的排序算法，它的核心思想是选择一个基准元素，将数组划分为两个子数组，其中一个子数组的所有元素都小于等于基准元素，而另一个子数组的所有元素都大于基准元素。然后，对这两个子数组递归地应用同样的过程，直到每个子数组只包含一个元素为止。

下面是使用C++语言实现快速排序算法的示例代码：

1. #include <iostream>
   
2. using namespace std;
   
3. 
   
4. // 交换数组中两个元素的位置
   
5. void swap(int* a, int* b) {
   
6.     int temp = *a;
   
7.     *a = *b;
   
8.     *b = temp;
   
9. }
   
10. 
    
11. // 将基准元素放到合适的位置，并返回其索引
    
12. int partition(int arr[], int low, int high) {
    
13.     int pivot = arr[high]; // 选择最后一个元素作为基准
    
14.     int i = low - 1; // i表示已经处理完的元素的最右边界
    
15. 
    
16.     for (int j = low; j < high; j++) {
    
17.         if (arr[j] < pivot) {
    
18.             i++;
    
19.             swap(&arr[i], &arr[j]);
    
20.         }
    
21.     }
    
22. 
    
23.     swap(&arr[i + 1], &arr[high]);
    
24. 
    
25.     return (i + 1);
    
26. }
    
27. 
    
28. // 使用快速排序算法对数组进行排序
    
29. void quickSort(int arr[], int low, int high) {
    
30.     if (low < high) {
    
31.         int pivotIndex = partition(arr, low, high);
    
32.         quickSort(arr, low, pivotIndex - 1);
    
33.         quickSort(arr, pivotIndex + 1, high);
    
34.     }
    
35. }
    
36. 
    
37. int main() {
    
38.     int arr[] = { 10, 7, 8, 9, 1, 5 };
    
39.     int n = sizeof(arr) / sizeof(arr[0]);
    
40. 
    
41.     quickSort(arr, 0, n - 1);
    
42. 
    
43.     cout << "排序后的数组：";
    
44.     for (int i = 0; i < n; i++) {
    
45.         cout << arr[i] << " ";
    
46.     }
    
47. 
    
48.     return 0;
    
49. }

复制代码

以上代码演示了如何使用快速排序算法对整数数组进行排序。首先，我们定义了两个辅助函数，`swap()`用于交换数组中两个元素的位置，`partition()`用于将基准元素放到合适的位置并返回其索引。

然后，在`quickSort()`函数中，我们选择基准元素，并通过调用`partition()`函数将数组划分为两个子数组。然后，对这两个子数组递归地应用相同的过程，直到每个子数组只包含一个元素。

最后，在`main()`函数中，我们创建一个示例数组并调用`quickSort()`函数对它进行排序。排序完成后，我们输出排序后的数组。

快速排序算法的平均时间复杂度为O(nlogn)，其中n是数组的大小。它是一种高效的排序算法，并且在实践中被广泛使用。

求最佳答案

isdkz

你的问题描述中并没有提供图或者明确的“加法结果”和“减法结果”，不过我理解你的问题可能是关于排序算法的。我看到你这里使用的是一种冒泡排序的方式来对数组进行排序。

你的问题可能出在下面这部分：

1. if (a[i] < a[c]) {
   
2.     e = a[i];
   
3.     a[i] = a[c];
   
4.     a[c] = e;
   
5.     continue;
   
6. }
   

复制代码

在这个地方，你是在判断如果 a[i] 的值小于 a[c] 的值，就交换他们的位置。这是一种升序排序的方式。换言之，如果你想要数组的值从小到大排列，那么这种方式是正确的。

如果你想要的是降序排列，也就是从大到小排列，那么你需要改变这个比较的条件。换成 if (a[i] > a[c]) 就可以实现降序排列。

具体到你的问题，“加法”和“减法”我不太清楚你在哪里使用，如果可以的话，你需要提供更多的信息。

同时，这个冒泡排序的效率并不高，对于更大的数组，你可能需要使用更高效的排序算法，例如快速排序、归并排序等。

如果你有更多关于编程的问题，欢迎继续提问。

sfqxx

isdkz 发表于 2023-7-6 09:04
你的问题描述中并没有提供图或者明确的“加法结果”和“减法结果”，不过我理解你的问题可能是关于排序算法 ...

《没有提供图》
gpt4不行啊？

kaishao

帅！谢谢大佬，虽然我刚学c看不懂您的代码，但是这看起来特别nb。

sfqxx

kaishao 发表于 2023-7-6 10:36
帅！谢谢大佬，虽然我刚学c看不懂您的代码，但是这看起来特别nb。