Более простой способ сортировки трех чисел

Вызовите три переменные x, y и z, затем:

if (x > y) swap(x, y);
if (y > z) swap(y, z)
if (x > y) swap(x, y);

Написание 9X_c функции swap оставлено в качестве упражнения 9X_c для читателя. Подсказка: возможно, вам придется 9X_c использовать указатели.

#include 
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))
int main(){
   int a, b, c;
   int hi;
   int lo;

   printf("Enter No. 1: ");
   scanf("%d", &a);
   printf("Enter No. 2: ");
   scanf("%d", &b);         
   printf("Enter No. 3: ");
   scanf("%d", &c);

   lo = min(min(a, b), c);
   hi = max(max(a, b), c);
   printf("LOWEST %d\n", lo);
   printf("MIDDLE %d\n", a+b+c-lo-hi);
   printf("HIGHEST %d\n", hi);  

   getchar(); 
}    
9X_c

Если вы хотите отсортировать значения по 9X_c новым внешним переменным, вы действительно 9X_c можете выполнить замену без временных изменений:

void sort(int a, int b, int c, int *min, int *mid, int *max) {
    min = a;
    mid = b;
    max = c;
    if (min > mid) { mid = a; min = b; }
    if (mid > max)
    {
        max = mid;
        mid = c;
        if (min > mid)
        {
            mid = min;
            min = c;
        }
    }
}

Это 9X_c работает, потому что последний тест подкачки 9X_c действительно нужен только в том случае, если 9X_c второй тест завершится успешно (в противном 9X_c случае это будет просто повторение первого 9X_c теста, который по определению потерпит неудачу, поскольку 9X_c мы уже отсортировали эти переменные).

Благодаря 9X_c этому мы можем отслеживать присвоения каждой 9X_c из исходных переменных и избегать замены 9X_c локальных переменных.

Подсказка: если у вас есть 3 числа, a, b 9X_c и c, min (a, min (b, c)) - наименьшее, max 9X_c (a, max (b, c)) - наибольшее, и задано наименьшее 9X_c и наибольшее числа, третье должно быть легко 9X_c найти.

Вот компактная версия Julia без ответвлений.

function sort_asc(a, b, c)
    l1, h1 = minmax(a, b)
    lo, h2 = minmax(l1, c)
    md, hi = minmax(h1, h2)
    return lo, md, hi
end

9X_c

Да, есть способ лучше, но вам нужно использовать 9X_c циклы и массивы.

Возможно, для вводного курса 9X_c ваш ответ - это тот ответ, который они ищут.

Есть 9X_c способы создать цикл с помощью for / while 9X_c (рекурсия, переход и т. д.). И способы получить 9X_c что-то вроде массива без индексации (int *ptr = malloc (3 * sizeof(int)), а 9X_c затем индексировать с помощью *(ptr+index)). Но мне 9X_c трудно представить, что они этого хотят.

Чтобы найти min, mid и max из 3 значений, вы можете 9X_c использовать тернарный оператор. Вы можете либо выполнять 9X_c всю свою работу в основной части кода, либо 9X_c разделить вычисления minof3, midof3 и maxof3 на функции многократного 9X_c использования.

В случае min и max вы просто делаете 9X_c 2 из 3 возможных сравнений, а затем возвращаете 9X_c сравнение результатов. В случае mid вы делаете 9X_c то же самое, но вычисляете минимальное и 9X_c максимальное из трех значений, а затем сравниваете 9X_c все три значения с min и max , чтобы найти значение, которое 9X_c не является ни min, ни max. (вы можете выполнить 9X_c эту часть в основной части кода без дополнительной 9X_c функции, объявив минимальное и максимальное 9X_c значения как переменные и выполнив там исключение).

Собрав 9X_c части вместе, вы можете сделать что-то подобное 9X_c следующему, в котором в качестве значений 9X_c для сортировки используются первые 3 аргумента 9X_c (или используются значения по умолчанию 9X_c 99, 231, 8, если необходимое значение не указано)

#include 
#include 

/** direct ternary comparison of 3 values */
long minof3 (long a, long b, long c) {
    long x = a < b ? a : b,
         y = a < c ? a : c;
    return x < y ? x : y;
}

long maxof3 (long a, long b, long c) {
    long x = a > b ? a : b,
         y = a > c ? a : c;
    return x > y ? x : y;
}

long midof3 (long a, long b, long c) {
    long x = minof3 (a, b, c),
         z = maxof3 (a, b, c),
         y = a == x ? b : a;
    return y == z ? c : y;
}

int main (int argc, char **argv) {

    long x = argc > 1 ? strtol (argv[1], NULL, 10) : 99,
         y = argc > 2 ? strtol (argv[2], NULL, 10) : 231,
         z = argc > 3 ? strtol (argv[3], NULL, 10) : 8;

    printf ("\n sorted values : %ld, %ld, %ld\n",
            minof3 (x, y, z), midof3 (x, y, z), maxof3 (x, y, z));

    return 0;
}

Пример использования / вывода

$ ./bin/sort3
 sorted values : 8, 99, 231

$ ./bin/sort3 -23 -281 1031
 sorted values : -281, -23, 1031

(да, я 9X_c знаю, что это старый пост, но, учитывая 9X_c недавний комментарий о коде, скрытом за 9X_c функцией swap, полный пример был в порядке).

Следующий код выполняет только от 2 (лучший 9X_c случай) до 3 (наихудший случай) условных 9X_c тестов без операций присваивания и каких-либо 9X_c дополнительных переменных:

void echo(int _1st, int _2nd, int _3rd) { printf("%d %d %d", _1st, _2nd, _3rd); }
void echoFrom(int pivot, int x, int y) {
    (pivot < y) ? ((x < y) ? echo(pivot, x, y) : echo(pivot, y, x)) : echo(y, pivot, x);
}
void printSorted(int a, int b, int c) { (a < b) ? echoFrom(a, b, c) : echoFrom(b, a, c); }

Базовый вызов (scanf() для простоты 9X_c опущено):

int main() {
    printSorted(2,3,1); //Output: 1 2 3
}