默认数组为升序

冒泡排序：

1. 比较相邻的两个元素。首先比较第一个和第二个数，如果第一个数比第二个数大，则交换这两个数，否则无需交换。接着比较第二个数和第三个数，如果第二个数比第三个数大，则交换这两个数，否则无需交换。依次进行比较，比较次数为n-1次。
2. 完成i+1(0<=i<n)趟后，会将最大的数字移至数组下表为n-i-1的位置。针对所有的元素，重复1的步骤。

排序的数组为{6, 2, 8, 1, 4, 9, 3, 0, 5, 7};

冒泡排序代码

#include<iostream>
using namespace std;
void swap( int array[], int i1, int i2 ) {  //交换数字的方法 
    int temp = array[i1];
    array[i1] = array[i2];
    array[i2] = temp;
}
void bubbleSort(int array[], int len ) {    //冒泡排序方法 
    for( int i = 0; i < 10; i++ ) {         //第一层for循环，每循环一次，将找出最大的数排在末尾 
        for( int j = 0; j < 10-i; j++ ) {   //第二层for循环
            if( array[j] > array[j+1] ) {   //若为降序，则交换两数 
                swap( array, j, j+1 );
            }
        }
    }
}
int main() {
    int array[] = {6, 2, 8, 1, 4, 9, 3, 0, 5, 7};
    bubbleSort( array, 10 );    //调用冒泡排序方法 
    for( int i = 0; i < 10; i++ ) { //输出结果 
        cout << "array[" << i << "] = " << array[i] << endl;
    }
} 

冒泡排序原理

                   冒泡排序，排序的表格

1. 在第一层循环中：

   1. 首先array[0]和array[1]比较，array[0]>array[1]，两数交换；即:array[0]=2,array[1]=6。
      此时数组array[]={2, 6, 8, 1, 4, 9, 3, 0, 5, 7};
   2. array[1]和array[2]比较，array[1]<array[2],不需要交换；
      此时数组array[]={2, 6, 8, 1, 4, 9, 3, 0, 5, 7};
   3. array[2]和array[3]比较，array[2]>array[3]，两数交换；即：array[2]=1,array[3]=8;
      此时数组array[]={2, 6, 1, 8, 4, 9, 3, 0, 5, 7};
   4. array[3]和array[4]比较，array[3]>array[4]，两数交换；即：array[3]=4,array[4]=8;
      此时数组array[]={2, 6, 1, 4, 8, 9, 3, 0, 5, 7};
      ……
   5. array[8]和array[9]比较，array[8]>array[9]，两数交换；即：array[8]=7,array[9]=9;

2. 第一层循环排序的结果为：
   2, 6, 1, 4, 8, 3, 0, 5, 7, 9

3. 同理，第二层排序的结果
   2, 1, 4, 6, 3, 0, 5, 7, 8, 9

4. 第三层排序结果：
   1, 2, 4, 3, 0, 5, 6, 7, 8, 9
   ……

5. 第八层排序结果：
   0, 1, 2, 3, 4, 5, 6, 7, 8, 9

6. 第九层排序结果：
   0, 1, 2, 3, 4, 5, 6, 7, 8, 9

如，对数组{6, 2, 8, 1, 4, 9}6个数字进行排序

第一趟循环

第二趟循环

第三趟循环

综上可得：
升序排序中，外层循环每循环一次，都会将最大的数字排在末尾；
同理，降序排序，外层循环每循环一次，都会将最小的数字排在末尾。