1.冒泡排序

1.思想：

冒泡排序的思想其实挺简单易懂的。

        想象有一排高矮不齐的瓶子，我们要把它们从矮到高排好序。 冒泡排序就像是这样一个过程：从最左边开始，依次比较相邻的两个瓶子。如果左边的瓶子比右边的高，那就把它们交换位置。这样一轮下来，最高的那个瓶子就像气泡一样“冒”到了最右边。

        然后我们再从头开始，重复这个比较和交换的过程，但是这一次不用管已经在最右边的那个最高的瓶子了。这样一轮一轮地进行，每次都能让当前未排序部分的最高的瓶子“冒”到正确的位置，直到所有的瓶子都排好序。

比如说，有一组数字 5、3、8、2、1 。

第一轮比较：

        - 先比较 5 和 3 ，5 大，交换位置，变成 3、5、8、2、1 。

        - 再比较 5 和 8 ，位置不变，还是 3、5、8、2、1 。

        - 接着比较 8 和 2 ，8 大，交换位置，变成 3、5、2、8、1 。

        - 最后比较 8 和 1 ，8 大，交换位置，变成 3、5、2、1、8 。

这一轮结束，最大的 8 就“冒”到了最右边。

        然后第二轮，对前面 4 个数重复同样的操作，直到全部排好序。 这种方法就像气泡一点点往上冒，所以叫冒泡排序。

2.图示：

3.伪码：

void Bubble_Sort( ElementType A[], int N )
{ 
    for ( P=N-1; P>=0; P-- ){
        flag = 0;
        for( i=0; i<P; i++ ) { /* 一趟冒泡 */
            if ( A[i] > A[i+1] ) {
                Swap(A[i], A[i+1]);
                flag = 1; /* 标识发生了交换 */
            }
        }
    if ( flag==0 ) break; /* 全程无交换 */
    }
}

4.时间复杂度：

最好情况：顺序	T = O( N )
最坏情况：逆序	T = O( N2 )

5.稳定性：

        稳定。 

完整代码示例：

#include <stdio.h>

// 交换两个元素的函数
void Swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 冒泡排序函数
void Bubble_Sort(int A[], int N) {
    int P;
    int flag;
    int i;
    for (P = N - 1; P >= 0; P--) {
        flag = 0;
        for (i = 0; i < P; i++) {
            if (A[i] > A[i + 1]) {
                Swap(&A[i], &A[i + 1]);
                flag = 1;
            }
        }
        if (flag == 0) break;
    }
}

// 打印数组的函数
void PrintArray(int A[], int N) {
	int i; 
    for (i = 0; i < N; i++) {
        printf("%d ", A[i]);
    }
    printf("\n");
}

// 测试示例
int main() {
    int A[] = {64, 34, 25, 12, 22, 11, 90};
    int N = sizeof(A) / sizeof(A[0]);

    printf("排序前的数组为: ");
    PrintArray(A, N);

    Bubble_Sort(A, N);

    printf("排序后的数组为: ");
    PrintArray(A, N);

    return 0;
}