我在数组中的指针无法正常工作

Question

我想创建一个函数，它可以接受 1:array_of_int 和 2:size_of_array，然后返回 3 个最大 int 的总和。代码如下：

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

int max_3(int arr[], int asize)
{ 
   int max_arr[3];
   int max =0; 
   int sum = 0;
   int* pi; 

   for(int j=0; j<3; j++)
   {   
      for(int i =0; i<asize;i++)
      {   
         if(arr[i] > max)
         {
           max = arr[i];
           pi = (arr + i); // to know the address of the max int of 'i' cycle
         }
      }   
      max_arr[j] = max;
      *pi = 0; // make the max int = 0 so that the next 'i' cycle doesnt have the previous max in it 
               //(so it can look for another max value - the second one)
   }   

   for(int i=0; i<3; i++)
      sum += max_arr[i];

   return sum;
}


int main (int argc, char** argv) {
   int arr[6] = {1,5,9,12,16,14};
   printf("%i\n",max_3(arr, 6));
   return (EXIT_SUCCESS);
}

指针pi 不会使当前max 的值变为0，并且for (int i..) 中的下一个循环与上一个一样再次变为最大。因此，它没有返回 max val1 + val2 + val3，而是返回 3 * val1（最大的一个）——在我的特定示例中——它打印出 48 而不是 42 (12 + 16 + 14)——它应该.但是当我将地址的值（我的指针指向的）设置为0 时如何？我不是很明白。

Answer 1

您的if 声明：

if (arr[i] > max)

在您第一次找到max 后不会输入（即当j > 0 时）。

您需要在之后将其归零：

max_arr[j] = max;
max = 0;

Answer 2

以下建议代码：

1. 执行所需的功能
2. 其算法非常简单
3. 采用冒泡排序来选择数组中的前三个条目
4. 消除“神奇”数字 6
5. 将第二个参数修改为size_t，因为这是sizeof()返回的类型
6. 表达式：sizeof(arr)/sizeof(arr[0]) 让编译器计算数组中的条目数
7. 语句：int arr[] = {1,5,9,12,16,14}; 让编译器为数组分配空间
8. 避免在排序时修改原始数组

现在，建议的代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>  // memcpy()


void swap(int *xp, int *yp) 
{ 
    int temp = *xp; 
    *xp = *yp; 
    *yp = temp; 
} 


// A function to implement bubble sort 
void bubbleSort(int arr[], size_t n) 
{ 
    size_t i;
    size_t j; 
    for (i = 0; i < n-1; i++)  
    {     
       // Last i elements are already in place    
       for (j = 0; j < n-i-1; j++)  
       {
            if (arr[j] > arr[j+1]) 
            {
              swap(&arr[j], &arr[j+1]); 
            }
        }
    }
} 


int max_3(int arr[], size_t asize)
{ 
    int localArray[ asize ];
    memcpy( localArray, arr, asize*sizeof( int ) );
    // sort array
    bubbleSort( localArray, asize );

    // calculate sum of max 3 entries
    int sum = localArray[asize-1] + localArray[asize-2] + localArray[asize-3];
    return sum;
}   


int main ( void ) 
{
   int arr[] = {1,5,9,12,16,14};
   printf( "%i\n", max_3( arr, sizeof(arr)/sizeof(arr[0])) );
   return (EXIT_SUCCESS);
}

运行建议的代码会导致：

42

Answer 3

在外循环（循环for(int j=0; j<3; j++)）的第一次迭代之后，max 和pi 的值将永远不会改变。

在外循环的第一次迭代中，您会发现数组中的第五个元素最大，max 将等于 16，pi 将指向该元素。您将max_arr[0] 设置为16 并将*pi 设置为零。然后外部循环以max 重新开始，仍然等于16。现在数组中将没有任何值等于或大于该值。因此，您也将max_arr[1] 设置为16，并将*pi（其中pi 仍指向第五个元素）设置为零再次。下一次迭代也是如此。

自然的解决方案是定义max 和pi inside 外循环：

for(int j=0; j<3; j++)
{
    // The variables will be redefined and reinitialized each iteration of the loop
    int max = 0;
    int *pi;

    for(int i =0; i<asize;i++)
    {
        if(arr[i] > max)
        {
            max = arr[i];
            pi = (arr + i); // to know the address of the max int of 'i' cycle
        }
    }
    max_arr[j] = max;
    *pi = 0; // make the max int = 0 so that the next 'i' cycle doesnt have the previous max in it
             //(so it can look for another max value - the second one)
}

代码还有一些其他问题，例如pi 可能永远不会被初始化。我把它作为一个练习留给读者来判断什么时候会发生以及如何解决它。