用指向指针的指针的方法对n个整数排序并输出

### 回答1：
可以使用指向指针的指针的方法对n个整数排序并输出。

具体实现方法如下：

1. 定义一个指向指针的指针，用于存储n个整数的地址。

2. 动态分配n个整数的内存空间，并将每个整数的地址存储到指向指针的指针中。

3. 使用冒泡排序或快速排序等算法对n个整数进行排序。

4. 输出排序后的n个整数。

代码示例：

#include <stdio.h>
#include <stdlib.h>

void sort(int **p, int n) {
    int i, j, temp;
    for (i = ; i < n - 1; i++) {
        for (j = ; j < n - i - 1; j++) {
            if (*p[j] > *p[j + 1]) {
                temp = *p[j];
                *p[j] = *p[j + 1];
                *p[j + 1] = temp;
            }
        }
    }
}

int main() {
    int n, i;
    int **p;

    printf("请输入整数个数n：");
    scanf("%d", &n);

    // 动态分配n个整数的内存空间
    p = (int **)malloc(n * sizeof(int *));
    for (i = ; i < n; i++) {
        p[i] = (int *)malloc(sizeof(int));
        printf("请输入第%d个整数：", i + 1);
        scanf("%d", p[i]);
    }

    // 对n个整数进行排序
    sort(p, n);

    // 输出排序后的n个整数
    printf("排序后的结果为：");
    for (i = ; i < n; i++) {
        printf("%d ", *p[i]);
    }
    printf("\n");

    // 释放内存空间
    for (i = ; i < n; i++) {
        free(p[i]);
    }
    free(p);

    return ;
}

### 回答2：
要用指向指针的指针的方法对n个整数排序并输出，我们需要采用双重指针的方式，即一个指针指向一个指针，而这个指针又指向要排序的数组。这样做的好处是可以不动原有的数组，直接对指针中存储的地址进行操作即可。

首先，我们需要定义一个指向指针的指针变量 **pp，用来存储指向每个整数地址的指针数组的地址，即 int *p[n] 数组的名字。

然后，我们需要用选择排序或冒泡排序等常见的排序算法对这 n 个整数进行排序。在排序的过程中，我们要用到两个指针，一个是指向最小值的指针 min_ptr，另一个是指向当前遍历的元素的指针 cur_ptr。需要注意的是，每次找到最小值后，我们需要交换 min_ptr 和 cur_ptr 指向的地址，从而将最小值放到正确的位置。

最后，我们可以对排序后的整数数组进行遍历输出，或者直接输出指针数组中每个指针所指向的整数即可。

下面是一份示例代码，它通过指向指针的指针排序 n 个整数，并输出排序后的结果：

#include <stdio.h>

void sort(int **pp, int n)
{
int *min_ptr, *cur_ptr, *temp;
for(int i=0; i<n-1; i++){
min_ptr = pp[i];
for(int j=i+1; j<n; j++){
cur_ptr = pp[j];
if(*min_ptr > *cur_ptr){
min_ptr = cur_ptr;
}
}
if(min_ptr != pp[i]){
temp = pp[i];
pp[i] = min_ptr;
min_ptr = temp;
}
}
}

int main()
{
int n = 5;
int arr[n] = {4, 1, 5, 2, 3};
int *p[n];

for(int i=0; i<n; i++){
p[i] = &arr[i];
}
sort(p, n);

printf("排序后的结果为：\n");
for(int i=0; i<n; i++){
printf("%d ", *p[i]);
}

return 0;
}

### 回答3：
排序是计算机科学中非常常见的问题之一。经典的排序算法有冒泡排序、选择排序、插入排序、快速排序等。这些算法中，插入排序的时间复杂度为O(n^2)，但在数据量比较小时，效率还是比较高的。

如果我们要用指向指针的指针的方法对n个整数排序并输出，可以按照以下步骤进行操作：

1. 定义一个指向指针的指针类型的变量double **p。

2. 动态分配n个整型指针的存储空间，即p = (int**)malloc(n * sizeof(int*))。

3. 为每个指针分配一个存储空间，并将其指向相应的整数，即for (i = 0; i < n; i++) { p[i] = (int*)malloc(sizeof(int)); *p[i] = a[i]; }，其中a[]是要排序的n个整数。

4. 对p中指向的指针所指向的整数进行插入排序，即for (i = 1; i < n; i++) { temp = *p[i]; j = i - 1; while (j >= 0 && *p[j] > temp) { *p[j + 1] = *p[j]; j--; } *p[j + 1] = temp; }，其中temp是中间变量。

5. 输出排序后的n个整数，即for (i = 0; i < n; i++) printf("%d ", *p[i])。

6. 释放内存，即for (i = 0; i < n; i++) free(p[i]); free(p)。

总之，对于指向指针的指针的方法来说，我们实际上是将需要排序的n个整数转化为指针的数组，并进行插入排序。虽然这种方法比较繁琐，但是它可以增强我们对指针和动态内存分配的理解，同时也可以提高程序的灵活性和可扩展性。