01.冒泡排序

1、概述：

1.  已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不变。
2. 再比较a[2]与a[3]的值，若a[2]大于a[3]则交换两者的值，否则不变。再比较a[3]与a[4]，以此类推，最后比较a[n-1]与a[n]的值。
3.  这样处理一轮后，a[n]的值一定是这组数据中最大的。再对a[1]~a[n-1]以相同方法处理一轮，则a[n-1]的值一定是a[1]~a[n-1]中最大的。
4. 再对a[1]~a[n-2]以相同方法处理一轮，以此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升序排列了。
5. 降序排列与升序排列相类似，若a[1]小于a[2]则交换两者的值，否则不变，后面以此类推。
6. 总的来讲，每一轮排序后最大（或最小）的数将移动到数据序列的最后，理论上总共要进行n(n-1）/2次交换。
7.  优点：稳定
8. 时间复杂度：理想情况下（数组本来就是有序的），此时最好的时间复杂度为o(n),最坏的时间复杂度(数据反序的)，此时的时间复杂度为o(n*n) 。
9. 冒泡排序的平均时间负责度为o(n*n).
10. 缺点：慢，每次只移动相邻的两个元素。

2、图解：

3、代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 冒泡排序
{
    class Program
    {

        static void Main(string[] args)
        {
            int[] data = new int[] { 42, 20, 17, 27, 13, 8, 17, 48,1,22 };
            BubbleSort(data);
            foreach (var temp in data)
            {
                Console.Write(temp + " ");
            }
            Console.ReadKey();
        }

        //以下展示的是两种实现方法，推荐使用第一种：

        /// <summary>
        /// 最底下元素对应最小索引
        /// </summary>
        /// <param name="dataArray"></param>
        static void BubbleSort(int[] dataArray)
        {
            for (int i = 0; i < dataArray.Length; i++)          //有多少个数就要遍历多少趟
            {
                for (int j = 0; j < dataArray.Length - 1 - i; j++)
                //每一次会将最小的一个排在首位，所以次数会依次减少   -i只是为了性能考虑，因为每一次都会将最大值放到最后，所以最后一个值可以随趟数进行减少
                {
                    if (dataArray[j] > dataArray[j + 1])  //交换位置
                    {
                        int temp = dataArray[j];
                        dataArray[j] = dataArray[j + 1];
                        dataArray[j + 1] = temp;
                    }
                }
            }
        }

        //从上到下
        //static void BubbleSort(int[] dataArray)
        //{
        //    for (int i = 0; i < dataArray.Length; i++)
        //    {
        //        for (int j = dataArray.Length - 1; j > i; j--)
        //        {
        //            if(dataArray[j]<dataArray[j-1])         //如果前一个元素大于最后面一个元素则交换位置
        //            {
        //                int temp = dataArray[j];
        //                dataArray[j] = dataArray[j - 1];
        //                dataArray[j - 1] = temp;
        //            }
        //        }
        //    }
        //}
    }
}