Question

我想减少嵌套循环的使用以及使用冒泡排序技术进行排序的变量数量。在传统的代码中，将有两个for循环或while和＆amp;的组合。 for循环。在这种情况下，如果内部循环的唯一原因是遍历到数组的起始索引，直到最近减少的数组大小的长度，我认为这可以避免一个＆＃34;如果＆＃34 ;检查单循环如下图所示。

是否可以使用＆＃34; if＆＃34;检查替换内部循环使运行时间与传统算法中的内部for循环相比更差吗？实际上是否需要使用for循环而不是＆＃34;如果＆＃34;？如果传统算法是代码的一部分，其中包含太多不可避免的嵌套循环和＆＃34;如果＆＃34;对于其他实施的陈述，圈复杂度会增加。
我想问一下，当结尾出现时，会不会对这种情况下使用的交换算法产生影响？

以下是代码：

void Bubble_Sort(int *arr, int size)
{
    int index = 0;
    /* pointer to array */
    int* temp = arr;

    while(size > 1)
    {
        /* Initial check if i has traversed up till
             last but one element of array
        */
        if(index == (size-1))
        {
            /* Set loop counter again from beginning*/
            index =0;
            /* Decrement the number of elements to traverse upto */
            size--;
            /* Set back pointer to start index of array */
            temp = arr;
        }

        /* Swapping algorithm */
        if(*temp > *(temp+1))
        {
            *temp ^= *(temp+1);
            *(temp+1) ^= *temp;
            *temp ^= *(temp+1);
        }

        /* Go to next element in array */
        temp++;

        index++;
    }
}

Answer 1

冒泡排序虽然是一种非常低效的排序算法，但已被尊敬的计算机科学家优化。当前的最优算法是（以伪代码的形式）：

sort (A, n)     // bubble sort array A[0..n-1]
{
    k= n-1;         // k holds position of last interchange. All higher elements are sorted.
    while (k > 0)
    {
        l= 0;
        for (j=0; j < k; j++)
        {
            if (A[j] > A[j+1])
            {
                tmp   = A[j];
                A[j]  = A[j+1];
                A[j+1]= tmp;
                l= j;
            }
        }
        k= l;
    }
}

冒泡排序实现

1 个答案: