对输入的n个整数进行排序。1<=n<=100。
 选择冒泡排序，首先要知道冒泡排序的时间复杂度为o(n^2)，空间复杂度为o(n)。本题中n最大为100，时间和空间都可以接受。
 
#include<iostream>
using namespace std;
int main()
{
	int c[100],n=0;  //n为1到100
	while(cin>>n)    //输入n
	{
		for(int i=0;i<n;i++)
		{
			cin>>c[i];  //循环n次，给数组赋值
		}
		for(int j=0;j<n;j++)  //冒泡排序
		{
			for(int k=0;k<n-j-1;k++)
			{
				if(c[k]>c[k+1])
				{
					int temp=c[k];
					c[k]=c[k+1];
					c[k+1]=temp;
				}
			}
		}
		for(int p=0;p<n;p++)  //输出排序
			cout<<c[p]<<' ';
	}

	return 0;
}

冒泡排序是一种比较简单的排序算法，它循环走过需要排序的元素，依次比较相邻的两个元素，如果顺序错误就交换，直至没有元素交换，完成排序。
 若对n个人进行排序，我们需要n-1次比较，所以第k次比较需要进行n-k次比较。排序算法通过以数据对象的两两比较作为关键，所以可以得出，冒泡排序需要进行的
 比较次数为：(n-1) + (n-2) + … + 1 = n*(n-1) / 2，因此冒泡排序的时间复杂度为O(n^2)
 
 以js实现为例：
 
   //1.冒泡排序-s--两两比较，大的和小的换位置
   let dataList=[12,2,3,46,1,2,8];
   let hasSort=[];
  //第一遍循环 n-1 次  (n=dataList.length)
   for(let i=0;i<dataList.length;i++){
  //第二遍循环 n-i-1 次
         for(let j=0;j<i;j++){
           if(dataList[i]>dataList[j]){
            let _data = dataList[i]
            dataList[i] = dataList[j]
            dataList[j]=_data
           }
         }
         hasSort.push(dataList[i]);
   }
   console.log("hasSort:"+hasSort)
   //1.冒泡排序-end

冒泡排序的概念：冒泡排序（Bubble Sort）是一种简单的交换排序，它是通过两两比较相邻记录的关键字，如果发生逆序就进行交换，从而使关键字小的记录如气泡一般逐渐往上“漂浮”（左移），或者使关键字大的记录如石块一样向下“坠落”（右移）。
 
冒泡排序的思想：就是将关键字进行两两比较，如果发生逆序就进行交换。
 
冒泡排序的思路过程：例如将49,38,65,97,76,13,27,49进行冒泡排序
 
初始化：49,38,65,97,76,13,27,49*
 
第一趟排序：38,49,65,76,13,27,49*,97
 
第二趟排序：38,49,65,13,27,49*,76,97
 
第三趟排序：38,49,13,27,49*,65,76,97
 
第四趟排序：38,13,27,49,49*,65,76,97
 
第五趟排序：13,27,38,49,49*,65,76,97
 
实际上对于这一系列数字就行五趟冒泡排序就可以将其按照顺序排出但实际上在写代码的过程中循环次数是7而不是5，因为你在写代码的时候并不需要考虑最少需要多少趟完成此排序，都是按照最大循环次数（数组的长度length-1）来完成此排序的。
 
冒泡排序每一趟都可以将一个较大的数放到后面的去，而且冒泡排序是稳定排序，何为稳定排序在这里不做详细说明。
 
接下来将用代码去实现冒泡排序：
 
/*利用冒泡排序对给定无序数组进行排序*/
#include<stdio.h>
#include<windows.h>
void main()
{
	int a[8] = { 49, 38, 65, 97, 76, 13, 27, 49 };
	int i, j;//用于循环
	int temp;//中间变量用于交换数组中的数值
	for (i = 0; i < 7; i++)//外层循环要循环数字数值长度减1次
	{	
		/*内层循环的次数将越来越少，因为冒牌排序第一趟就可以将数
		组中最大的一个数放到最后，第二趟就可以将次大的数放在后面
		，所以随着外层循环次数的增多，内层循环将会变少。*/
		for (j = 0; j < 7 - i; j++)
		{
			if (a[j]>a[j+1])//逆序则借助中间变量交换数值
			{
				temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
			}
		}
	}
	printf("冒泡排序的结果为：\n");
	for (i = 0; i < 8; i++)//将数组输出
	{
		printf("%3d",a[i]);
	}
	printf("\n");
	system("pause");//暂停一下
}
 
代码运行的截图：
 

 
 
冒泡排序的原理有一下几个步骤
 
1 逐一比较数组中相邻的两个元素,如果后面的数字小于前面的数组,就交换前后元素
 
2 经过一轮的比较之后一定有一个最大的排在后面的位置
 
3 每次比较剩下的元素,经过n-1次比较,可以实现排序.
 
 
 
package me;

import java.util.Arrays;

public  class Me {
    public static void main(String[] args) {
      int [] arr = {3,2,5,8,6,4,9}; //用冒泡排序
        for (int i=0;i<arr.length-1;i++){ //遍历数组 第一个元素定义为i
            for (int j=0;j<arr.length-1-i;j++){ //遍历数组定义第二个元素为j,加入i是3那么数组中j就是2
                if (arr[j]>arr[j+1]){ //如果第一个元素大于第二个元素 交换
                    int value = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1]=value;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    
   
}
 
如果这个交换元素的值不清楚的话可以看下图