Question

我试图获取数组的第n个数字，我试图对数组进行排序，然后通过索引访问第n个数字；我已经编写了这段代码：

#include <iostream>
using namespace std;
int largest(int a[],int k){

   for (int i=0;i<=(sizeof(a)/sizeof(*a));i++){
      for (int j=i+1;j<=(sizeof(a)/sizeof(*a));j++){

         if(a[j]>a[i]){
            int temp=a[i];
            a[i]=a[j];
            a[j]=temp;
         }
      }
   }
   return a[k-1];
}

int main()
{
   int a[]={3,2,1,0,5,10};
   int m=largest(a,4);
   cout<<m<<endl;

   return 0;
}

，当我打印出m时，它看起来是5而预期是2；当我尝试用int m=largest(a,4);替换m=largest(a,1);时，它打印了2，所以看起来他打印数组a的索引，但不对其进行排序，知道吗？

Answer 1

问题在于使用sizeof(a)/sizeof(*a)来获取数组元素的数量。 sizeof(a)是指针的大小。

您需要将数组的大小传递给函数。

int largest(int a[], int size, int k){

   for (int i=0;i<size;i++){
      for (int j=i+1;j<size;j++){

      ...
      }
   }
}

并用

调用

int m = largest(a, 6, 4);

Answer 2

您的代码存在三个问题。

首先，当您将数组作为函数的参数传递时，它会衰减为指针。因此，如果没有其他信息，该函数将永远无法知道数组的大小。 main()的工作是查找数组的大小并将该信息传递给largest()。

第二，由于尝试从0迭代到数组中的元素数，因此代码中出现了一个错误的错误。

以下将起作用：

#include <iostream>
using namespace std;
int largest(int a[],int k, int n){
   for (int i = 0; i < n; i++){
      for (int j = i + 1; j < n; j++){
         if (a[j] > a[i]){
            int temp = a[i];
            a[i] = a[j];
            a[j] = temp;
         }
      }
   }
   return a[k-1];
}

int main()
{
   int a[] = {3, 2, 1, 0, 5, 10};
   int k = 4;
   int m = largest(a, k, sizeof a/ sizeof *a);
   cout << m << endl;
}

最后但并非最不重要的一点是，您的功能有令人讨厌的副作用。如果您有一个应该找到数组最大元素的函数，则不应为了整个目的而修改整个数组。

您可以复制原始数组并将其排序。或者，您可以实现k元素排序算法。无论哪种方式，您都不应该仅仅为了从用户数据中找到一些统计信息而更改用户数据。

Answer 3

#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
   int a[]={3,2,1,0,5,10};
   std::sort(a, a+6, greater<int>() );  // Sort an array of 6 elements in greatest-first order.
   cout<<a[3]<<endl;                    // Show the 4th element from the front.

   return 0;
}

Answer 4

UPD：：可以使用STL算法：std :: nth_element。

#include <iostream>
#include <algorithm>
int main(){
    int arr[] = {54, 897, 87, 4, 6,987};
    size_t length = 6, k = 3;
    std::cout<<std::nth_element(arr, arr + k, arr + length, std::greater<int>());
}

此外，如果您想自己实现它，则可以基于快速排序来做这样的事情：

#include <iostream>
#include <algorithm>

template<class T>
T largest_k(T* a, size_t left, size_t right, size_t k) {
  if(left>=right)
    return a[k-1];

  size_t i = left, j = right;   

  T middle = a[ i + (j-i) / 2 ];    

  do {
    while ( a[i] > middle ) i++;
    while ( a[j] < middle ) j--;

    if (i <= j) {
      std::swap(a[i], a[j]);
      i++; j--;
    }
  } while ( i<=j );

  // We need to go deeper only for needed part of a
  if ( k<=j+1 )
    return largest_k(a, left, j, k);
  if ( k>= i ) 
    return largest_k(a, i, right, k);
}

int main()
{
  int arr[] = {54, 897, 87, 4, 6,987};
  size_t length = 6, k = 3;
  std::cout<<largest_k<int>(arr, 0, length-1, k);
}

获得第n大数字

4 个答案: