C 气泡排序实现

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

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

我想问，当endianess出现在图片中时，会不会对本例中使用的交换算法产生影响

代码如下：

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

---

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

排序（A，n）//冒泡排序数组A[0..n-1] { k=n-1；//k保持最后一次交换的位置。所有较高的元素都已排序。 而（k>0） { l=0； 对于（j=0；jA[j+1]） { tmp=A[j]； A[j]=A[j+1]； A[j+1]=tmp； l=j； } } k=l； } }

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