Question

void sort(int* A,int l)
{
    int j;
    int B[l];
    for(int i=0;i<l;i++)
    {
        j = largest(A,l);
        B[l-i-1] = A[j];
        A[j] = -1;
    }
    A = B;
 }
  int main()
  {
   .
   int C[3] = {x,y,z};
   ...
    sort(C,3);
     cout<<C[0]<<C[1];
    }

输出将为-1-1 但是如果我们分配A [0] = B [0]等等，那么我们得到了正确的答案。 PS：我尝试使用* A = * B，这只是让第一个元素正确。

Answer 1

分配A = B时，重新分配一个本地变量，该变量包含指向数组第一个元素的指针。此作业不会更改main中的任何内容。特别是，A的内容不会受到影响。

完成排序后，您必须将所有元素从B复制到A：

void sort(int *A, int l)
{
    int j;
    int B[l];

    // sort into temporary array B    
    for (int i = 0; i < l; i++) {
        j = largest(A, l);
        B[l - i - 1] = A[j];
        A[j] = -1;
    }

    // copy temporary array B to result array A
    for (int i = 0; i < l; i++) A[i] = B[i];
}

但是如果你看一下，Amol Bavannavar基本上是正确的：你不必每次检查整个阵列中最大的元素。足以检查剩余的元素。因此，不要将低值分配给＆＃34;使用＆＃34;元素，您可以将最大的元素交换到最后。当您这样做时，您将看到已处理的元素位于最后，未处理的元素位于开头。然后你可以在不需要临时数组的情况下进行排序：

void sort2(int *A, int l)
{
    while (l) {
        int j = largest(A, l--);
        int swap = A[j]; A[j] = A[l]; A[l] = swap;
    }
}

Answer 2

您的示例中有许多错误的代码用法，例如：

int B[l];

无法完成，如果你这样做，我必须有一个常数值。

A = B;

将执行浅拷贝而不是深拷贝。你可以在这里看到差异：What is the difference between a deep copy and a shallow copy?

cout<<C[0]<<C[1];

将打印连接在一起的数字而不进行解析。

至于如何修复此代码，您可能希望实现的一个实现是：

#include <iostream>

using namespace std;

int largest(int* A, int l)
{
int big=-1;
int i;
int index=0;
for(i=0;i<l;i++)
{
    if(A[i]>big)
    {
        big=A[i];
        index=i;
    }
}
return index;
}

void sort(int* A,int l)
{
int j;
int *B=new int[l];
for(int i=0;i<l;i++)
{
    j = largest(A,l);
    B[l-i-1] = A[j];
    A[j] = -1;
}
for(int i=0;i<l;i++)
{
    A[i]=B[i];
}
}
int main()
{
 int C[3] = {2,5,1};
 sort(C,3);
 cout<<C[0]<<" "<<C[1];
 return 1;
}

数组没有正确分配

2 个答案: