冒泡排序

1：原理

以此比较相邻的两个元素，每次比较完毕最大的一个字跑到本轮的末尾。 
目的：按从小到大排序。 
方法： 
假设存在数组：72, 54, 59, 30, 31, 78, 2, 77, 82, 72 
第一轮比较相邻两个元素，如果左边元素大于右边元素，则交换。 
72和54比较的结果就是，54在前，72在后； 
然后72和59比较的结果，59在前，72在后； 
以此类推，第一轮比较之后的结果是：54, 59, 30, 31, 72, 2, 77, 78, 72, 82 
经过第一轮比较，最大的元素跑到了最后一个，所以第二轮比较，最后一个元素不需要进行比较了。  
第二轮还是从索引0和1开始比较，只是不许要比较最后一个了，算法还是一样的。第三轮、第四轮以此类推。 

    class Program
    {
        /// <summary>
        /// 冒泡排序(从小到大)
        /// </summary>
        /// <param name="a"></param>
        /// <returns></returns>
        public static int[] bubble(int[] a)
        {
            //临时变量
            int temp = 0;
            //第一层循环i是比较的轮数,也是两数比较的次数
            for (int i = a.Length - 1; i > 0;i--)
            {
                //第二层循环每次j都从1开始
                for (int j = 1; j <= i;j++)
                {
                    //前数大于后数
                    if (a[j-1]>a[j])
                    {
                        //将前数的值赋予临时变量
                        temp = a[j - 1];
                        //把后数的值赋给前数
                        a[j - 1] = a[j];
                        //把临时变量存储的前数值赋给后数
                        a[j] = temp;
                    }
                }
            }
            return a;
        }

        static void Main(string[] args)
        {
            int[] a = new int[] { 72, 54, 59, 30, 31, 78, 2, 77, 82, 72 };
            int[] b=bubble(a);
            for (int i = 0; i < b.Length;i++)
            {
                Console.WriteLine(b[i] + "
");
            }
            Console.Read();
        }
    }

2.冒泡排序时间复杂度： 

    冒泡排序是一种用时间换空间的排序方法，最坏情况是把顺序的排列变成逆序，或者把逆序的数列变成顺序。在这种情况下，每一次比较都需要进行交换运算。举个例子来说，一个数列 5 4 3 2 1 进行冒泡升序排列，第一次大循环从第一个数（5）开始到倒数第二个数（2）结束，比较过程：先比较5和4，4比5小，交换位置变成4 5 3 2 1；比较5和3，3比5小，交换位置变成4 3 5 2 1……最后比较5和1，1比5小，交换位置变成4 3 2 1 5。这时候共进行了4次比较交换运算，最后1个数变成了数列最大数。
第二次大循环从第一个数（4）开始到倒数第三个数（2）结束。进行3次比较交换运算。
……
所以总的比较次数为 4 + 3 + 2 + 1 = 10次
对于n位的数列则有比较次数为 (n-1) + (n-2) + ... + 1 = n * (n - 1) / 2，这就得到了最大的比较次数
而O(N^2)表示的是复杂度的数量级。举个例子来说，如果n = 10000，那么 n(n-1)/2 = (n^2 - n) / 2 = (100000000 - 10000) / 2，相对10^8来说，10000小的可以忽略不计了，所以总计算次数约为0.5 * N^2。用O(N^2)就表示了其数量级（忽略前面系数0.5）。