c - 冒泡排序的实现

Question

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

1. 与传统算法中的内部 for 循环相比，使用“if”检查替换内部循环的实现是否会使运行时间更差？是否真的需要使用 for 循环而不是“if”？如果传统算法的代码的一部分包含太多不可避免的嵌套循环和用于其他实现的“if”语句，则会增加圈复杂度。

2. 我想问一下，当使用字节顺序时，会对这种情况下使用的交换算法产生影响吗？

代码如下:

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;
    }
}