【问题标题】:c - Sorting twenty ints using passByValue [closed]c - 使用 passByValue 对 20 个整数进行排序 [关闭]
【发布时间】:2019-03-22 16:42:40
【问题描述】:

所以我得到了一个家庭作业,我有 20 个硬编码的整数,每个整数都是随机数。有些可能是一样的。使用 passByValue,我需要打印三个最高的数字。

现在我已经计划好了。这些数字将在 main 中声明,每个数字将被发送到一个新函数,可能称为排序。我将有三个整数,它们将采用较高的数字(通过的数字,或每个点已经存在的数字),然后将两者中较大的一个分配给该整数,然后再分配给该函数中的其他两个。

不过,我有两个问题。问题一是主要的。 作业说明明确指出我不能使用数组。所以我所能想象的只是二十个不同的整数,每个都有不同的值。但是,这里的问题是,如果我使用 passByValue,我真的不能同时对它们进行排序。或者也许我可以,但它看起来不漂亮,而漂亮是老师要找的。​​p>

那么问题一,我如何有效地将每个整数一个接一个地传递给排序函数?

问题二:我不希望 print 函数在完成排序之前打印出三个最大的数字。我能想象这种工作的唯一方法是以某种方式保持值不被发送到打印函数,直到 main 中的 int 行用完。但我不确定这是否可能......

显然我不是在寻找整个代码。我真正在寻找的只是一个可以遵循的方向。我是否可以在 main 和 sort 函数或结构中使用某种形式的递归(尽管我不知道我的老师是否会欣赏我使用这些,因为它们类似于数组)或其他东西。

【问题讨论】:

  • 如果“不能使用数组”为真,则很难使用printf(),因为它的格式通常是char 数组。 “我有二十个硬编码的整数”听起来确实像一个数组。建议发布您尝试过的内容,否则这太宽泛且不清楚。
  • 从您的命名开始:您实际上并没有尝试对任何内容进行排序 - 您正在寻找最大的 3 个数字。您会惊讶于您的想法可能会受到限制,因为您选择了名称sort。您正在尝试解决排序问题,而不是手头的问题。
  • I need print the three highest numbers. 如果有平局怎么办?
  • 你的老师考虑int *list = malloc(n * sizeof(int))然后*(list+x)使用数组吗?
  • 使用排序网络展开排序算法,使用 20 个整数而不对其进行索引,然后打印最高的 3 个。

标签: c sorting pass-by-value


【解决方案1】:

您可以很容易地制作一个没有数组和递归的可扩展解决方案。即,您可以将 20 更改为 20,000,而无需额外的资源。

这是一些示例伪代码:

for(int i = 0; i < 20; i++)
{
    // TODO
    // -1 is a sample start value. You can find a better one
    int biggest = -1;
    int second_biggest = -1;
    int third_biggest = -1;
    int num = generate_random_num();
    if (num > third_biggest)
    {
        // TODO
        // check against second_biggest and biggest too
        // set one of the variables but remember: if you set biggest, what was
        // in biggest is now second_biggest and the old second_biggest is now
        // third_biggest
    }
    // TODO
    // Print the 3 results

这可以重构以支持a1=13, a2=42...a20=666。您的 biggest 变量成为全局变量。您的 if (num &gt; third_biggest) 被包装在一个函数中,您为每个变量调用一次。

【讨论】:

  • "我有 20 个硬编码整数"
  • @Swordfish 如果它是硬编码的,只需打印答案。显然 OP 不是在寻找那个,这个答案增加了价值。
【解决方案2】:

使用 Bose-Nelson 算法计算 20 个整数的数量我创建了一个简单的函数,它对使用名称索引的 20 个整数进行排序,使用 this site。然后你只需要返回 3 个最大的整数。

#include <stdio.h>

struct max3_from_20_s {
    int first;
    int second;
    int third;
} max3_from_20(
    int v0,
    int v1,
    int v2,
    int v3,
    int v4,
    int v5,
    int v6,
    int v7,
    int v8,
    int v9,
    int v10,
    int v11,
    int v12,
    int v13,
    int v14,
    int v15,
    int v16,
    int v17,
    int v18,
    int v19
) {
#define SORT20_MIN(a, b)  ((a<b)?a:b)
#define SORT20_MAX(a, b)  ((a<b)?b:a)
#define SORT20_SWAP(idx1, idx2)  do{ \
        const int min = SORT20_MIN(v##idx1, v##idx2); \
        const int max = SORT20_MAX(v##idx1, v##idx2); \
        v##idx1 = min; \
        v##idx2 = max; \
    }while(0)
#define swap SORT20_SWAP

    swap(0, 1);
    swap(3, 4);
    swap(5, 6);
    swap(8, 9);
    swap(10, 11);
    swap(13, 14);
    swap(15, 16);
    swap(18, 19);
    swap(2, 4);
    swap(7, 9);
    swap(12, 14);
    swap(17, 19);
    swap(2, 3);
    swap(1, 4);
    swap(7, 8);
    swap(6, 9);
    swap(12, 13);
    swap(11, 14);
    swap(17, 18);
    swap(16, 19);
    swap(0, 3);
    swap(5, 8);
    swap(4, 9);
    swap(10, 13);
    swap(15, 18);
    swap(14, 19);
    swap(0, 2);
    swap(1, 3);
    swap(5, 7);
    swap(6, 8);
    swap(10, 12);
    swap(11, 13);
    swap(15, 17);
    swap(16, 18);
    swap(9, 19);
    swap(1, 2);
    swap(6, 7);
    swap(0, 5);
    swap(3, 8);
    swap(11, 12);
    swap(16, 17);
    swap(10, 15);
    swap(13, 18);
    swap(1, 6);
    swap(2, 7);
    swap(4, 8);
    swap(11, 16);
    swap(12, 17);
    swap(14, 18);
    swap(0, 10);
    swap(1, 5);
    swap(3, 7);
    swap(11, 15);
    swap(13, 17);
    swap(8, 18);
    swap(4, 7);
    swap(2, 5);
    swap(3, 6);
    swap(14, 17);
    swap(12, 15);
    swap(13, 16);
    swap(1, 11);
    swap(9, 18);
    swap(4, 6);
    swap(3, 5);
    swap(14, 16);
    swap(13, 15);
    swap(1, 10);
    swap(2, 12);
    swap(7, 17);
    swap(4, 5);
    swap(14, 15);
    swap(3, 13);
    swap(2, 10);
    swap(6, 16);
    swap(8, 17);
    swap(4, 14);
    swap(3, 12);
    swap(5, 15);
    swap(9, 17);
    swap(8, 16);
    swap(4, 13);
    swap(3, 11);
    swap(6, 15);
    swap(9, 16);
    swap(4, 12);
    swap(3, 10);
    swap(7, 15);
    swap(4, 11);
    swap(8, 15);
    swap(7, 12);
    swap(4, 10);
    swap(9, 15);
    swap(6, 11);
    swap(8, 13);
    swap(5, 10);
    swap(9, 14);
    swap(8, 12);
    swap(6, 10);
    swap(9, 13);
    swap(8, 11);
    swap(9, 12);
    swap(7, 10);
    swap(9, 11);
    swap(8, 10);
    swap(9, 10);
#undef swap

    struct max3_from_20_s ret = {
        v19, v18, v17,
    };
    return ret;
}

int main()
{
    struct max3_from_20_s num = max3_from_20(
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
        20, 19, 18, 17, 100, 15, 14, 13, 12, 11
    );
    printf("%d %d %d\n", num.first, num.second, num.third);

    return 0;
}

将输出:

100 20 19

您可以使用任何变量名称,只需稍微修改宏并将交换调用中的每个数字替换为等效名称。

onlinegdb 提供实时版本。

【讨论】:

  • 这到底是什么意思?在编译期间甚至不排序。你只是手动展开了循环。
  • @AjayBrahmakshatriya 这是一个有效的答案。它在不使用数组的情况下对 20 个值进行排序,在编译时排序不是必需的,它使用 Sorting Network(一种非常有用的技术)。
  • @AjayBrahmakshatriya 重点是使用 20 个不同的整数对按值传递的 20 个整数进行排序,并明确要求不使用数组,然后在排序后不打印它们,而是返回给调用者.这就是问题所在。通过展开循环,您可以有效地将变量命名为任何名称,因为您只剩下一些简单的赋值v1 = max(v1, v2); v2=min(v1, v2);。这个问题不涉及在编译时对它们进行排序,这个函数也不这样做。
【解决方案3】:
#include <stdlib.h>
#include <stdio.h>

#pragma pack(1)
typedef struct stupid_assignment_data_tag {
    int a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t;
} stupid_assignment_data_t;

int cmp(void const *a, void const *b)
{
    if(*(int*)a > *(int*)b) return  1;
    if(*(int*)a < *(int*)b) return -1;
    return 0;
}

void stupid_assignment_function(stupid_assignment_data_t stupid_assignment_data)
{
    qsort(&stupid_assignment_data, 20, sizeof(int), cmp);

    struct { char a, b, c, d, e, f, g, h, i, j, k; }
        stupid_format_string = { '%', 'd', ' ', '%', 'd', ' ', '%', 'd', '\0' };

    printf((char const*)&stupid_format_string, stupid_assignment_data.r, stupid_assignment_data.s, stupid_assignment_data.t);
}

int main(void)
{
    stupid_assignment_data_t stupid_assignment_data{
        2, 45, 765, 345, 15, 56, 3, 47, 457, 1235, 234,
        324, 234, 56346, 567, 4, 457, 4356, 24, 42 };

    stupid_assignment_function(stupid_assignment_data);
}

...您可能想在提交代码之前更改一些标识符...或者不。

如果“不能使用数组”为真,则很难使用 printf(),因为它的格式通常是 char 数组。

好点。处理好了。

【讨论】:

  • 鉴于我们知道这是作业,我们被告知不要使用数组,像这里所做的那样在数组周围偷偷摸摸似乎并不“安全”。另外:如果我戴上语言律师的帽子,结构中的元素是否保证是连续的?我不这么认为。
  • 我现在明白为什么使用#pragma pack(1) - 来规避“不能使用数组”。
  • @chux 是的,我错过了 ;-) 虽然我的观点现在更加强烈 - 如果看起来像初学者课程的解决方案依赖于 pragma,那么我闻起来很腥......跨度>
  • @John3136 当然是fishy ;-)
  • 等一下。让我打开我的划痕和嗅探监视器......
【解决方案4】:

也许我错过了你的解释,但我想你可以做这样的事情......

// Globals to store the highest numbers. Initialize them to 0 considering the values are all positive.
int high_num_1 = 0;
int high_num_2 = 0;
int high_num_3 = 0;

void look_for_highest_numbers(int new_value)
{
    // You can put the code to get the highest values here
    // and assign them to the global ints declared above
}

void print_highest(void)
{
    // print the highest numbers
}

void main(void)
{
    // very stupid way of extracting the highest values from 20 ints
    look_for_highest_numbers(100);
    look_for_highest_numbers(42);
    ... // dots are to show that here you place another 17 calls to look_for_highest_numbers()
    look_for_highest_numbers(12345);
    // print solution
    print_highest();
}

我真的不明白这个作业的意义,也许你可以问问你的老师,让我们知道......

【讨论】:

    猜你喜欢
    • 2021-01-08
    • 2014-08-16
    • 2018-04-29
    • 2014-07-20
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    相关资源
    最近更新 更多