C 如何在指针数组中传递完整数组

我写了一个程序对数组的值进行排序。它有5个阵列

    int arr1[] = { 3, 9, 6, 7 };
    int arr2[] = { 2, 5, 5 };
    int arr3[] = { 0 };
    int arr4[] = { 1, 6 };
    int arr5[] = { 4, 5, 6, 2, 1 };

int* pArr[LEN] = { arr1, arr2, arr3, arr4, arr5 };

还有一个指针数组，包含这5个数组

    int arr1[] = { 3, 9, 6, 7 };
    int arr2[] = { 2, 5, 5 };
    int arr3[] = { 0 };
    int arr4[] = { 1, 6 };
    int arr5[] = { 4, 5, 6, 2, 1 };

int* pArr[LEN] = { arr1, arr2, arr3, arr4, arr5 };

我想对每个数组的值进行排序，但是当我将数组传递给排序函数时

sortArrValues(&pArr[i]);

它将每个数组的第一个索引（

arr1

，

arr2

…）视为该数组的元素（

pArr[i]

），因此

pArr[i]

为（3,2,0,1,4）。
但是我希望

pArr[I]

是它想要的完整数组，因此在第一次迭代中

pArr[I]

将是（3,9,6,7）

注意：每个数组的第一个索引表示该数组的长度（不包括该索引）。
排序将跳过第一个索引。
还有两个附加函数，它们未被使用（您可以跳过它们）

以下是完整的代码：

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

#define LEN 5

void sortArrValues(int** arr);
void sortArrAdress(int* pArr);
void printArr(int * pArr);

int main()
{
    int arr1[] = { 3, 9, 6, 7 };
    int arr2[] = { 2, 5, 5 };
    int arr3[] = { 0 };
    int arr4[] = { 1, 6 };
    int arr5[] = { 4, 5, 6, 2, 1 };

    int* pArr[LEN] = { arr1, arr2, arr3, arr4, arr5 };

    int  i = 0;

    for (i = 0; i < LEN; i++)
    {
        sortArrValues(&pArr[i]);
    }

    //sortArrAdress(pArr);
    //printArr(pArr);

    return 0;
}
/*
this function will sort the given arrays' values.
in: array
out: none
*/
void sortArrValues(int** arr)
{
    int tmp = 0;
    int i = 0;

    for (i = 1; i < *arr; i++)
    {
        if (*arr[i] > *arr[i+1])
        {
            tmp = *arr[i];
            *arr[i] = *arr[i + 1];
            *arr[i + 1] = tmp;
        }
    }
}

#包括
#包括
#包括
#定义LEN 5
无效排序值（整数**arr）；
void sortArrAdress（int*pArr）；
无效打印阵列（int*pArr）；
int main（）
{
int arr1[]={3,9,6,7}；
int arr2[]={2,5,5}；
int arr3[]={0}；
int arr4[]={1,6}；
int arr5[]={4,5,6,2,1}；
int*pArr[LEN]={arr1，arr2，arr3，arr4，arr5}；
int i=0；
对于（i=0；i*arr[i+1]）
{
tmp=*arr[i]；
*arr[i]=*arr[i+1]；
*arr[i+1]=tmp；
}
}
}

您的代码中有一些错误

首先，您不需要发送

&pArr[i]

，

pArr[i]

就足以订购阵列。然后你的

void-sortArrValues（int**arr）

变成

void-sortArrValues（int*arr）

，这样读起来更清晰

其次，在你的排序值中，当你改变一个值时，你应该重新开始（我知道这不是很优化，但是如果你想让事情变得更快，你应该使用快速排序。在你的代码中，

{4,5,6,2,1}

将变成

{4,5,2,1}

这就是您的修复代码：

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

#define LEN 5

void sortArrValues(int* arr);
void sortArrAdress(int* pArr);
void printArr(int * pArr);

int main()
{
    int arr1[] = { 3, 9, 6, 7 };
    int arr2[] = { 2, 5, 5 };
    int arr3[] = { 0 };
    int arr4[] = { 1, 6 };
    int arr5[] = { 4, 5, 6, 2, 1 };

    int* pArr[LEN] = { arr1, arr2, arr3, arr4, arr5 };

    int  i = 0;

    for (i = 0; i < LEN; i++)
    {
        sortArrValues(pArr[i]);
    }

    //sortArrAdress(pArr);
    //printArr(pArr);

    for (int i = 0 ; i < LEN ; i++) {
        for (int j = 0 ; j < pArr[i][0] + 1 ; j++)
            printf("%d ", pArr[i][j]);
        printf("\n");
    }

    return 0;
}
/*
this function will sort the given arrays' values.
in: array
out: none
*/
void sortArrValues(int* arr)
{
    int tmp = 0;
    int i = 0;

    for (i = 1; i < *arr; i++)
    {
        if (arr[i] > arr[i+1])
        {
            tmp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = tmp;
            i = 0;

        }
    }
}

#包括
#包括
#包括
#定义LEN 5
无效排序值（int*arr）；
void sortArrAdress（int*pArr）；
无效打印阵列（int*pArr）；
int main（）
{
int arr1[]={3,9,6,7}；
int arr2[]={2,5,5}；
int arr3[]={0}；
int arr4[]={1,6}；
int arr5[]={4,5,6,2,1}；
int*pArr[LEN]={arr1，arr2，arr3，arr4，arr5}；
int i=0；
对于（i=0；iarr[i+1]）
{
tmp=arr[i]；
arr[i]=arr[i+1]；
arr[i+1]=tmp；
i=0；
}
}
}

我试图修改您的程序以修复问题。其中一些问题已被其他人突出显示。有些问题没有突出显示。这是工作片段。如果您需要有关任何修改的更多说明，请告诉我。请注意，我只修改了您的

排序

函数。这样做的目的不是让您获得最快的排序速度戈里思，但这是一个有效的

int main()
{
    int arr1[] = { 3, 9, 6, 7 };
    int arr2[] = { 2, 5, 5 };
    int arr3[] = { 0 };
    int arr4[] = { 1, 6 };
    int arr5[] = { 4, 5, 6, 2, 1 };

    int* pArr[] = { arr1, arr2, arr3, arr4, arr5 };

    int  i = 0;

    for (i = 0; i < LEN; i++)
    {
        sortArrValues(&pArr[i]);
    }
}


void sortArrValues(int** arr)
{
    int tmp = 0;
    int i = 0, j = 0;

    for (i = 0; i < (**arr) - 1; i++)
    {
        for(j=i+1; j < (**arr) - 1; j++) {
           if ((*arr)[i+1] > (*arr)[j+1])
           {
               tmp = (*arr)[i+1];
               (*arr)[i+1] = (*arr)[j + 1];
               (*arr)[j+1] = tmp;
           }
        }
        printf("%d ", (*arr)[i+1]);
    }
    printf("%d\n", (*arr)[i+1]);
}

intmain（）
{
int arr1[]={3,9,6,7}；
int arr2[]={2,5,5}；
int arr3[]={0}；
int arr4[]={1,6}；
int arr5[]={4,5,6,2,1}；
int*pArr[]={arr1，arr2，arr3，arr4，arr5}；
int i=0；
对于（i=0；i（*arr）[j+1]）
{
tmp=（*arr）[i+1]；
（*arr）[i+1]=（*arr）[j+1]；
（*arr）[j+1]=tmp；
}
}
printf（“%d”，（*arr）[i+1]）；
}
printf（“%d\n”，（*arr）[i+1]）；
}

我假设它崩溃了？@StoryTeller不，它只是在由每个数组的第一个索引（3,2,0,1,4）组成的假数组中迭代。也许对运算符优先级的检查会有所帮助？

*arr[I]

->

（*arr）[I]

I<*arr应该是

I<**arr

当然，在C中的运算符优先级中，

[]

比

*

具有更高的优先级。因此，为了强制首先执行解除限制，必须将解除引用括在括号中。查找运算符优先级表，当事情没有意义时，它将保存您的培根。您应该限定是否需要任何其他排序例程，直到有几百个mo对于元素，它不会产生任何可测量的差异。使用C库中的

qsort

很难打败。它使用混合合并和快速排序，可以有效地处理大小数组。@DavidC.Rankin已经是我的答案，为了获得更好的性能，他应该使用快速排序算法。这不是我的观点。Th要点是，在你有几百个元素之前，你使用什么样的排序都无关紧要。你是对的，快速排序可以提供许多优点，但对于尝试自己编写的新手来说，它也有许多缺点。最好引导他们使用

qsort

，它是标准库的一部分，经过多年的优化和验证，它是在它上面。只是一个指向答案的指针（不是批评）。回答时，请尝试解释逻辑中的错误在哪里