Question

我正在使用Turbo C，我对我的代码有一些疑问。我只是感到困惑......程序首先要求输入一个数字列表（你不应该输入超过20个）。当用户输入数字时，它们将被放置在数组list[]中。一旦用户通过键入0 *（未列在列表中）*终止列表，程序就会调用sort()函数，该函数对列表中的值进行排序。在最后一部分，评论为/*I AM NOW CONFUSED WITH THIS PART*/，是我需要你帮助的部分......请帮助我。

enter image description here

       File   Edit   Run   Compile   Project   Options   Debug   Break/watch
    ╒════════════════════════════════════ Edit ════════════════════════════════════╕
    │      Line 1     Col 43  Insert Indent Tab Fill Unindent * C:NONAME.C         │
    │                                                                              │
    │ #define MAXSIZE 20                            /* size of buffter */          │
    │ void sort(int[], int);                        /* prototype */                |
    │                                                                              |
    │ main()                                                                       |
    │ {                                                                            |
    │     static int list[MAXSIZE];                 /* buffer for numbers */       |
    │     int size = 0;                             /* size 0 before input */      |
    │     int dex;                                  /* index of array */           |
    │     do                                        /* get list of numbers */      |
    │     {                                                                        |
    │         printf("Type number: ");                                             |
    │         scanf("%d", &list[size]);                                            |
    │     }                                                                        |
    │     while(list[size++] != 0);                 /* exit loop on 0 */           |
    │                                                                              |
    │     sort(list,--size);                        /* sort nubmers */             |
    │     for(dex=0; dex<size; dex++)               /* print sorted list */        |
    │         printf("%d\n", list[dex]);                                           |
    │                                                                              |
    │      getche();                                                               |
    │ }                                                                            |
    │                                                                              |
    │ void sort(int list[], int size)                                              |
    │ {                                                                            |
    │     int out, in, temp;                        /* I AM NOW CONFUSED */        |
    │                                                                              |
    │     for(out=0; out<size-1; out++)             /* IN THIS PART! */            |
    │         for(in=out; in<size; in++)                                           |
    │              if(list[out] > list[in])                                        |
    │              {                                                               |
    │                  temp=list[in];                                              |
    |                  list[in]=list[out];                                         |
    │                  list[out]=temp;                                             |
    │              }                                                               |
    │ }                                                                            |
    │                                                                              |
    │                                                                              |
    ├─────────────────────────────────── Watch ────────────────────────────────────┤
    │                                                                              │
    └──────────────────────────────────────────────────────────────────────────────┘
     F1-Help  F5-Zoom  F6-Switch  F7-Trace  F8-Step  F9-Make  F10-Menu   NUM

Answer 1

这只是用于对数组元素进行排序的代码，但它从来不会以当前形式工作：

temp=list[in];
list[out]=temp;

将使用list[out] 覆盖list[in]，而不会保留 list[out]的原始内容。

交换两个变量的最佳方法是：

temp = array[index1];
array[index1] = array[index2];
array[index2] = temp;

而且，对于你所信仰的任何神性的爱，请不要this： - ）

因此，如果您的问题是如何对数据进行排序，那么以下伪代码应该会有所帮助。我会提供C代码，但是，如果这是家庭作业，你应该自己做一些工作^a。

def sort (arr[], sz):
    swapped = true                       # Force loop entry.
    while swapped:                       # Loop until a pass had no swaps.
        swapped = false
        for idx goes from 1 to sz-1:     # For all but the first element.
            if arr[idx-1] > arr[idx]:    # If order is wrong.
                swapped = true           # More passes will be needed.
                temp = arr[idx-1]        # Swap
                arr[idx-1] = arr[idx]    #   the
                arr[idx] = temp          #     elements.

这是一个冒泡排序变体，一旦列表被排序就会退出（好吧，在没有交换的一次通过之后）。无论如何，一些天真的变体将大致持续n²次。

^a如果您想在评论中指出它是不是作业，我很乐意提供C代码。请注意（如果你打算骗我），你的教育工作者几乎肯定能够看到那些代码，你可能会在那种情况下失败（或因明显的抄袭而被驱逐出境）。

而且，既然你已经说过它不是家庭作业，这里有一个完整的C程序来说明它：

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

#define FALSE (1==0)
#define TRUE  (1==1)

static void sort (int arr[], int sz) {
    int idx, temp, swapped;

    swapped = TRUE;                        // Force loop entry.
    while (swapped) {                      // Loop until a pass had no swaps.
        swapped = FALSE;
        for (idx  = 1; idx < sz; idx++) {  // For all but the first element.
            if (arr[idx-1] > arr[idx]) {   // If order is wrong.
                swapped = TRUE;            // More passes will be needed.
                temp = arr[idx-1];         // Swap
                arr[idx-1] = arr[idx];     //   the
                arr[idx] = temp;           //     elements.
            }
        }
    }
}

int main (int argc, char *argv[]) {
    int sz, i, *vals;

    sz = argc - 1;
    if (sz < 1)
        return 0;
    if ((vals = malloc (sz * sizeof (int))) == NULL) {
        printf ("ERROR: Cannot allocate memory.\n");
        return 1;
    }

    for (i = 0; i < sz; i++)
        vals[i] = atoi (argv[i+1]);

    printf ("Numbers before:");
    for (i = 0; i < sz; i++)
        printf (" %d", vals[i]);
    printf ("\n");

    sort (vals, sz);

    printf ("Numbers after :");
    for (i = 0; i < sz; i++)
        printf (" %d", vals[i]);
    printf ("\n");

    free (vals);
    return 0;
}

用以下方式运行：

$ ./testprog 3 1 4 1 5 9 2 6 5 3 5 8 9

为您提供输出：

Numbers before: 3 1 4 1 5 9 2 6 5 3 5 8 9
Numbers after : 1 1 2 3 3 4 5 5 5 6 8 9 9

Answer 2

sort()最内层循环中的值交换不完整。它永远不会将list[in]分配给任何东西。

Answer 3

我相信以下是您要做的事情。基本上，您试图在每个内循环迭代中找到最小元素。例如，如果从数组[5,4,3,2,1]开始，在第一次内循环迭代之后，数组将如下所示：

[5,4,3,2,1]：在= 0之后

[4,5,3,2,1]：在= 1之后

[3,5,4,2,1]：在= 2之后

[2,5,4,3,1]：在= 3之后

[1,5,4,3,2]：在= 4之后

现在1开始了。最终，数组将被排序为[1,2,3,4,5]。

void sort(int list[], int size) {
    int out, in, temp;       
    for(out=0; out<size; out++)  {        |
        for(in=out; in<size; in++)                                           
            if(list[out] > list[in])                                        
            {                                                               
                tmp = list[out]
                list[out]=list[in];
                list[in] = tmp                                                                                           
            }    
    }                                                           
}

排序数组问题

3 个答案: