C 为什么我的选择不总是有效？

我是一名初学者，现在我正在第二天尝试实现SelectionSort以供练习。 我使用的算法大多数时候都有效，但并不总是有效。不幸的是，我完全不清楚为什么它不总是起作用。 举个例子，如果它不起作用

#include <stdio.h>

int* selectionSort(int a_count, int *a);

int main(void)
{
    int a[] =     {4,2,3,4,4,9,98,98,3,3,3,4,2,98,1,98,98,1,1,4,98,2,98,3,9,9,3,1,4,1,98,9,9,2,9,4,2,2,9,98,4,98,1,3,4,9,1,98,98,4,2,3,98,98,1,99,9,98,98,3,98,98,4,98,2,98,4,2,1,1,9,2,4};
    int i, a_count = 73;
    int *result = selectionSort(a_count, a);
        for(i = 0; i < a_count; i++){
            printf("%i ", result[i]);
        }
    return 0;
}   

int* selectionSort(int a_count, int* a) {
    int i, j, min = 0, tmp;
    for(i = 0; i < a_count - 1; i++){
        min = i;
        printf("min_i = %i\n", min);
        for(j = i + 1; j < a_count; j++){
            printf("j = %i ", j);
                if(a[j] < a[min]){
                printf("%i < %i\n", a[j], a[min]);
                printf("min is changed: ");
                min = j;
                printf("min_j = %i\n", min);
            }
            tmp = a[i];
            a[i] = a[min];
            a[min] = tmp;
        }
   }
   return a;
}

#包括
int*selectionSort（int a_计数，int*a）；
内部主（空）
{
INTA[]={4,2,3,4,4,9,98,98,3,3,4,2,98,1,98,98,98,1,1,4,98,2,98,3,3,9,3,1,9,9,3,1,9,9,9,2,2,9,9,9,4,2,9,4,4,98,1,98,4,2,3,98,98,1,98,1,99,9,98,98,2,98,4,2,4,98,4}；
int i，a_计数=73；
int*result=selectionSort（a_计数，a）；
对于（i=0；i

---

非常感谢你的帮助

在循环

j

的每次迭代中，您都将元素

i

与元素

min

交换。这既不正确又低效。在内部循环完成后执行交换，以便

min

实际上包含当前子数组最小值的索引，而不是在您仍然试图找出该元素的位置时。

在

j

上的每个循环迭代中，您都将元素

i

与元素

min

交换。这既不正确又低效。在内部循环完成后执行交换，以便

min

实际上包含当前子数组的最小值的索引，而不是在您仍试图找出该元素的位置时。

有一个简单的错误，即您没有等到内部循环结束时才进行交换

int* selectionSort(int a_count, int* a) {
    int i, j, min = 0, tmp;
    for(i = 0; i < a_count - 1; i++){
        min = i;
        printf("min_i = %i\n", min);
        for(j = i + 1; j < a_count; j++){
            printf("j = %i ", j);
                if(a[j] < a[min]){
                printf("%i < %i\n", a[j], a[min]);
                printf("min is changed: ");
                min = j;
                printf("min_j = %i\n", min);
            }
        }
        tmp = a[i];         //  three lines moved out of the loop
        a[i] = a[min];      //
        a[min] = tmp;       //
   }
   return a;
}

int*selectionSort（int a_计数，int*a）{
int i，j，min=0，tmp；
对于（i=0；i

---

现在输出是正确的。

有一个简单的错误，就是您没有等到内部循环结束时才进行交换

int* selectionSort(int a_count, int* a) {
    int i, j, min = 0, tmp;
    for(i = 0; i < a_count - 1; i++){
        min = i;
        printf("min_i = %i\n", min);
        for(j = i + 1; j < a_count; j++){
            printf("j = %i ", j);
                if(a[j] < a[min]){
                printf("%i < %i\n", a[j], a[min]);
                printf("min is changed: ");
                min = j;
                printf("min_j = %i\n", min);
            }
        }
        tmp = a[i];         //  three lines moved out of the loop
        a[i] = a[min];      //
        a[min] = tmp;       //
   }
   return a;
}

int*selectionSort（int a_计数，int*a）{
int i，j，min=0，tmp；
对于（i=0；i

---

现在输出是正确的。

您有两个循环，在外循环中，您首先设置了最小值，然后在内循环中，最小值发生了变化，这会弄乱最小值，使您的交换代码出错。 您可以删除关于min的所有代码，直接使用i，j，然后应该可以工作。 改变 如果（a[j]如果（a[j]您有两个循环，在外循环中，您首先设置了min，然后在内循环中，min发生了变化，这会弄乱min值，使您的交换代码出错。 您可以删除关于min的所有代码，直接使用i，j，然后应该可以工作。 改变 如果（a[j]

公共静态类选择排序
{
静态int-min；
公共静态无效排序（int[]数据）
{
for（int i=0；i

公共静态类选择排序
{
静态int-min；
公共静态无效排序（int[]数据）
{
for（int i=0；i

对于相同的数据，结果是否总是相同的？还是一个数据集并不总是有效？@WeatherVane它似乎总是一样的。对于相同的数据，结果总是一样的吗？或者一个数据集不总是有效吗？@WeatherVane它似乎总是一样的。你能解释一下吗？你能解释一下吗？