在冒泡排序中使用第二个for循环[关闭]

Question

有人可以在下面的冒泡排序中解释第二个for循环的确切目的吗？ 我理解第一个循环正在查看数组的第i个整数，但究竟第二个循环看到了什么？

请原谅我对这个话题的无知。 我已经编写了不到一周的编码，并且对这个问题感到有些困惑。

void sort(int array[], int size) {
  for(int i = 0, x = size - 1; i < x; i++) {
    for(int j = 0; j < x - 1; j++) {
      if(array[j] > array[j + 1]) {
        int tmp = array[j];
        array[j] = array[j + 1];
        array[j + 1] = tmp;
      }
    }
  }
}

Answer 1

我猜你的第一个循环也是错误的，考虑到你想要实现Bubble Sort ，因为第一个循环告诉排序列表所需的遍数。 在冒泡排序的情况下，它等于Total Number of elements - 1个遍数来排序n个元素的列表（n - 1）通过是必需的，因此在我的拙见中i的值必须从1开始，如果我没弄错。 此外，您提供的代码段与C语言编码样式不同，就您在需要时声明变量而言。

第二个循环基本上是为了减少比较（元素数量 - 传递-1），在每次迭代之后，因为每次传递，我们将最大元素放在右侧（逻辑未排序列表）。 因此，由于该元素处于合法位置，因此我们不必将其与其他元素进行比较。

  4 3 2 1 Original List
  3 2 1 4 Pass 1
        -
        Now since this above 4 is in it's rightful place
        we don't need to compare it with other elements.
        Hence we will start from the zeroth element and 
        compare two adjacent values, till 1 (for Pass 2)
        Here comparison will take place between 3 and 2,
        and since 3 is greater than 2, hence swapping 
        between 3 and 2, takes place. Now 3 is comapred
        with 1, again since greater value is on left
        side, so swapping will occur. Now 3 is not compared
        with 4, since both these values are in their 
        rightful place.
  2 1 3 4 Pass 2
      - 
        Now since this above 3 is in it's rightful place
        we don't need to compare it with other elements.
        Hence we will start from the zeroth element and 
        compare two adjacent values, till 1 (for Pass 3)
        Here only one comparison will occur, between
        2 and 1. After swapping 2 will come to it's rightful
        position. So no further comparison is needed.
  1 2 3 4 Pass 3
  Here the list is sorted, so no more comparisons, after Pass 3.    


void bubbleSort(int *ptr, int size)
{
        int pass = 1, i = 0, temp = 0;
        for (pass = 1; pass < size - 1; pass++)
        {
                for (i = 0; i <= size - pass - 1; i++)
                {
                        if (*(ptr + i) > *(ptr + i + 1))
                        {
                                temp = *(ptr + i);
                                *(ptr + i) = *(ptr + i + 1);
                                *(ptr + i + 1) = temp;
                        }
                }
                printf("Pass : %d\n", pass);
                for (temp = 0; temp < size; temp++)
                        printf("%d\t", *(ptr + temp));
                puts("");
        }
}

Answer 2

你的冒泡排序循环是错误的。 这是正确的：

void bubbleSort(int numbers[], int array_size) {
  int i, j, temp;

  for (i = (array_size - 1); i > 0; i--) {
    for (j = 1; j <= i; j++) {
      if (numbers[j-1] > numbers[j]) {
        temp = numbers[j-1];
        numbers[j-1] = numbers[j];
        numbers[j] = temp;
      }
    }
  }
}

第二个循环正在完成主要工作。 它比较每一对并交换它们的位置，使得较大的数字向右移动（右边靠近数组的末尾）。