（1）冒泡排序算法：（Bubble Sort）首先肯定是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

下面举一个简单的例子

原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 |

第一趟排序(外循环)

第一次两两比较6 > 2交换(内循环)

交换前状态| 6 | 2 | 4 | 1 | 5 | 9 |

交换后状态| 2 | 6 | 4 | 1 | 5 | 9 |

第二次两两比较,6 > 4交换

交换前状态| 2 | 6 | 4 | 1 | 5 | 9 |

交换后状态| 2 | 4 | 6 | 1 | 5 | 9 |

第三次两两比较,6 > 1交换

交换前状态| 2 | 4 | 6 | 1 | 5 | 9 |

交换后状态| 2 | 4 | 1 | 6 | 5 | 9 | 

第四次两两比较,6 > 5交换

交换前状态| 2 | 4 | 1 | 6 | 5 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

 第五次两两比较,6 < 9不交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 | 

第二趟排序(外循环)

第一次两两比较2 < 4不交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 | 

第二次两两比较,4 > 1交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 | 

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

 第三次两两比较,4 < 5不交换

交换前状态| 2 | 1 | 4 | 5 | 6 | 9 | 

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

 第四次两两比较,5 < 6不交换

交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

 第三趟排序(外循环)

第一次两两比较2 > 1交换

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

 第二次两两比较,2 < 4不交换

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

 第三次两两比较,4 < 5不交换

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 

第四趟排序(外循环)无交换

第五趟排序(外循环)无交换

排序完毕,输出最终结果1 2 4 5 6 9

冒泡算法之所以被叫做冒泡算法，应为它每趟排序都可以找出待排序元素中最大或者最小的一个，是一个很形象的称呼。

（2）C++源程序如下：

#include<iostream>

using namespace std;

#define N 10

int main()

{

int array[10];

int T=0;

cout<<“请输入”<<N<<“个数,并用空格隔开”<<endl;

for(int i=0;i<N;i++)

{

cin>>array[i];

}

printf(“排序前:\n”);

for(i=0;i<N;i++)

{

cout<<array[i]<<”  “;

}

for(i=0;i<N-1;i++)

{

for(int j=0;j<N-1-i;j++)

{

if(array[j]>array[j+1])

{

T=array[j];

array[j]=array[j+1];

array[j+1]=T;

}

}

}

printf(“\n排序后:\n”);

for(i=0;i<N;i++)

{

cout<<array[i]<<”  “;

}

printf(“\n”);

return 0;

}

运行结果如下：

注;在程序中我使用了宏定义，这样的话使程序更加灵活，适应性更强。