我正在尝试根据一些三角形的表面来排序。为此，三角形存储在名为三角形的结构数组中。为了解决这个问题，我的想法是创建一种具有三角形表面的并行数组，并“并行”交换两个数组。排序是在一个 void 函数中完成的，该函数接收数组及其中的元素数量。
排序似乎有效，我通过打印曲面数组进行检查，但是当我打印三角形数组（从函数内部和外部）时，它的顺序不正确。它既不是排序后的，也不是最初的。
我使用冒泡排序进行排序，我知道它效率低下，但实现起来也很简单。我知道我可以使用 qsort 函数，但为了学习，我想首先从头开始。这是代码，希望它足够可读：
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
struct triangle
{
int a;
int b;
int c;
};
typedef struct triangle triangle;
void sort_by_area(triangle* tr, int n) {
double s[n];
double p, s_2;
int u;
triangle v;
for (int i = 0; i < n; i++) {
p = (tr[i].a+tr[i].b+tr[i].b);
p = p/2.0;
s_2 = p*(p-tr[i].a)+(p-tr[i].b)+(p-tr[i].c);
s[i] = sqrt(s_2);
}
//bubble sort
for (int i = 0; i <n-1; i++) {
for (int j = 0; j < (n-i-1); j++) {
if (s[j]>s[j+1]) {
u = s[j];
s[j] = s[j+1];
s[j+1] = u;
v = tr[j];
tr[j]= tr[j+1];
tr[j+1] = v;
//printf("swapped");
}
}
}
for (int i = 0; i <n; i++) {
printf("%f\n", s[i]);
if (i == (n-1)) {
printf("\n\n");
}
}
}
int main()
{
int n;
scanf("%d", &n);
triangle *tr = malloc(n * sizeof(triangle));
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &tr[i].a, &tr[i].b, &tr[i].c);
}
sort_by_area(tr, n);
for (int i = 0; i < n; i++) {
printf("%d %d %d\n", tr[i].a, tr[i].b, tr[i].c);
}
return 0;
}
这是我尝试测试的输入示例：
10
67 67 19
3 57 55
33 33 33
61 58 59
23 43 35
48 42 45
23 12 27
41 34 22
26 49 35
63 46 45
我的结果是
23 12 27
41 34 22
33 33 33
63 46 45
48 42 45
23 43 35
26 49 35
61 58 59
3 57 55
67 67 19
您对 Heron 公式 的计算不正确，因为在
p*(p-tr[i].a)+(p-tr[i].b)+(p-tr[i].c)
您首先将半周长
pp - tr[i].a(p - tr[i].b) + (p - tr[i].c)参见：运算符优先级。
相反，您正在寻找半周长和从半周长中减去每条边的乘积：
p * (p - a) * (p - b) * (p - c)
每边的变量都已简化。
要做的第一件事是通过编写只做一件事的函数来简化代码，并且把它做好
static double herons(const struct triangle *t)
{
double p = (t->a + t->b + t->c) / 2.0;
return sqrt(p * (p - t->a) * (p - t->b) * (p - t->c));
}
并单独测试这些功能
#include <stdio.h>
#include <math.h>
struct triangle {
int a;
int b;
int c;
};
static double herons(const struct triangle *t)
{
double p = (t->a + t->b + t->c) / 2.0;
return sqrt(p * (p - t->a) * (p - t->b) * (p - t->c));
}
int main(void)
{
struct triangle tr[] = {
{ 67, 67, 19 },
{ 3 , 57, 55 },
{ 33, 33, 33 },
{ 61, 58, 59 },
{ 23, 43, 35 },
{ 48, 42, 45 },
{ 23, 12, 27 },
{ 41, 34, 22 },
{ 26, 49, 35 },
{ 63, 46, 45 }
};
for (size_t i = 0; i < (sizeof tr / sizeof *tr); i++)
printf("%2d %2d %2d herons(%.5f)\n", tr[i].a, tr[i].b, tr[i].c, herons(tr + i));
}
看看结果是否如你所愿
67 67 19 herons(630.06919)
3 57 55 herons(62.58744)
33 33 33 herons(471.55083)
61 58 59 herons(1522.35344)
23 43 35 herons(401.79869)
48 42 45 herons(869.02154)
23 12 27 herons(137.28802)
41 34 22 herons(373.85952)
26 49 35 herons(437.49286)
63 46 45 herons(1034.10638)
然后从那里继续前进。
从 vetted 库函数
qsortstatic int compare_by_area(const void *a, const void *b)
{
double l = herons(a);
double r = herons(b);
return (l > r) - (l < r);
}
qsort(tr, sizeof tr / sizeof *tr, sizeof *tr, compare_by_area);
示例用法，上面定义了数组。
当插入之前测试的示例时，给出了很好看的结果：
3 57 55 herons(62.58744)
23 12 27 herons(137.28802)
41 34 22 herons(373.85952)
23 43 35 herons(401.79869)
26 49 35 herons(437.49286)
33 33 33 herons(471.55083)
67 67 19 herons(630.06919)
48 42 45 herons(869.02154)
63 46 45 herons(1034.10638)
61 58 59 herons(1522.35344)
有了工作基线后，开始修改程序的一部分。这是排序函数的修改版本，使用在每一步重新计算面积的简单方法。
static void sort_by_area(struct triangle *tr, int n)
{
for (int i = 0; i < (n - 1); i++) {
for (int j = 0; j < (n - i - 1); j++) {
if (herons(tr + j) > herons(tr + j + 1)) {
struct triangle v = tr[j];
tr[j]= tr[j + 1];
tr[j + 1] = v;
}
}
}
}
如果我们对此进行测试，它会给出预期的结果。所以我们继续缓存结果：
static void sort_by_area(struct triangle *tr, int n)
{
double s[n];
for (int i = 0; i < n; i++)
s[i] = herons(tr + i);
for (int i = 0; i < (n - 1); i++) {
for (int j = 0; j < (n - i - 1); j++) {
if (s[j] > s[j + 1]) {
double u = s[j];
s[j] = s[j+1];
s[j+1] = u;
struct triangle v = tr[j];
tr[j]= tr[j + 1];
tr[j + 1] = v;
}
}
}
}
毫不奇怪，它仍然有效，因为它是基于之前测试的代码构建的。
下一步：将这种类型与天真的
qsort注意：如果
double s[n];nn注意：
int u;double-Wconversion-Wfloat-conversion