C 如何按升序或降序打印数组，而不干扰数组，也不使用临时数组或变量进行交换？

程序应该以升序或降序打印数组元素，而不会干扰数组，并且不能使用swap或任何临时变量

print_sort(array, sizeofarray);

---

使用数组指针并使用偏移量值访问数组值

#include <stdio.h>

int main () {

   /* an array with 5 elements */
   double balance[5] = {1000.0, 2.0, 3.4, 17.0, 50.0};
   double *p;
   int i;

   p = balance;

   /* output each array element's value */
   printf( "Array values using pointer\n");

   for ( i = 0; i < 5; i++ ) {
      printf("*(p + %d) : %f\n",  i, *(p + i) );
   }

   printf( "Array values using balance as address\n");

   for ( i = 0; i < 5; i++ ) {
      printf("*(balance + %d) : %f\n",  i, *(balance + i) );
   }

   return 0;
}

#包括
int main（）{
/*包含5个元素的数组*/
双平衡[5]={1000.0,2.0,3.4,17.0,50.0}；
双*p；
int i；
p=平衡；
/*输出每个数组元素的值*/
printf（“使用指针的数组值”）；
对于（i=0；i<5；i++）{
printf（“*（p+%d）：%f\n”，i，*（p+i））；
}
printf（“使用余额作为地址的数组值\n”）；
对于（i=0；i<5；i++）{
printf（“*（余额+%d）：%f\n”，i，*（余额+i））；
}
返回0；
}

来源：

中的（部分）溶液。如果数字重复，它就会中断

#include <assert.h>
#include <limits.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>

static bool is_smallest(const int *array, size_t size, int n, int min)
{
    assert(size != 0);

    if (size == 1)
    {
        if (array[0] <= min)
            return n > min;

        return n <= array[0];
    }

    return (array[0] <= min ? n > min : n <= array[0]) &&
        is_smallest(array + 1, size - 1, n, min);
}

static void print_sort2(const int *array, size_t size, size_t index, int min)
{
    if (index >= size)
        return;

    if (is_smallest(array, size, array[index], min))
    {
        printf("%d ", array[index]);
        print_sort2(array, size, 0, array[index]);
    }
    else
        print_sort2(array, size, index + 1, min);
}

static void print_sort(const int *array, size_t size)
{
    print_sort2(array, size, 0, INT_MIN);
    printf("\n");
}

int main(void)
{
    const int array[] = {-100, 32, -1, 4, 66, 0, -5, -500, 2};
    const size_t size = sizeof array / sizeof array[0];

    print_sort(array, size);
    print_sort((const int []){1, 5, 4, 2, 3}, 5);
    print_sort((const int []){1, 2, 3}, 3);
    print_sort((const int []){10, -10, 20, 30, 0}, 5);
}

#包括
#包括
#包括
#包括
#包括
静态布尔是最小的（常量int*数组，大小，整数n，整数min）
{
断言（大小！=0）；
如果（大小==1）
{
if（数组[0]min；
return n这是你的作业吗？允许你编写其他函数吗？否则，如果没有任何临时变量，它将是复杂的/不可能的。@mch是的，你可以编写任意数量的函数。@ShaheAnsar这不是任何类型的作业。这在我设计新的排序算法时引起了我的兴趣。这是如何输出项的按升序？OP请求的输出是
[2.0,3.4,17.0,50.0,1000.0]
，或者相反。您的代码不会对项目进行任何排序。另外，
p
和
i
是临时变量，这是不允许的。因此，您有一个递归方法，返回第n个最小的项目，并调用它n次？有趣的解决方案，尽管如果数组很大，它会导致堆栈崩溃。@JimMischel我的“解决方案”绝不实用，只是试图满足OP的严格要求（被视为挑战）。此外，它还有“吃重复值”bug，所以我正在等待其他人找到合适的解决方案。@user7023624感谢您的解决方案。现在我将尝试进行更改，以便它可以对重复编号的阵列运行。