冒泡排序法

基本思想

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
• 针对所有的元素重复以上的步骤，除了最后一个。
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

排序示例

时间复杂度

• 假设共有N个数，则需要遍历N - 1此，每次比较或交换的次数为N，则时间复杂度为O(N2)
• 交换过程中需要一个临时变量作为中介，所以空间复杂度为O(1)

稳定性

• 冒泡排序是稳定的算法，它满足稳定算法的定义。
• 算法稳定性 -- 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的！

实现

namespace Algorithm.DataStructure.Sort
{
    class BubbleSort:SortData
    {
        public BubbleSort():base()
        {
            Console.WriteLine("-======================冒泡排序法=================================");
        }

        public override void Sort(int[] array)
        {
            base.Sort(array);
            for(int i = array.Length - 1;i > 0; i--)
            {
                for(int j = 0; j < i; j++)
                {
                    if(array[j] > array[j+1])
                    {
                        int temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
            }
        }
    }
}

优化一

设置一个标志，如果这一趟发生了交换，则为false，否则为true。如果有一趟没有发生交换，说明排序已经完成。

public void bubbleSort2()
namespace Algorithm.DataStructure.Sort
{
    class BubbleSort:SortData
    {
        public BubbleSort():base()
        {
            Console.WriteLine("-======================冒泡排序法=================================");
        }

        public override void Sort(int[] array)
        {
            base.Sort(array);
            bool flag = false;
            int k = array.Length - 1;
            while(!flag)
            {
                flag = true;
                for(int i = 0; i < k ;i++)
                {
                    if(array[i] > array[i + 1])
                    {
                        int temp = array[i];
                        array[i] = array[i + 1];
                        array[i + 1] = temp;
                        flag = false;
                    }                
                }
                k--;
            }
        }
    }
}

优化二

如果有100个数的数组，仅前面10个无序，后面90个都已排好序且都大于前面10个数字，那么在第一趟遍历后，最后发生交换的位置必定小于10，且这个位置之后的数据必定已经有序了，记录下这位置，第二次只要从数组头部遍历到这个位置就可以了。

 public void bubbleSort1()
{
    int[] nums = { 1, 2, 4, 34, 5345, 34, 43, 342 };
    int temp = 0;
    int k = nums.Length - 1;
    int pos = 0;
    while (k>0)
    {
        pos = 0;
        for(int i=0;i<k;i++)
        {
            if(nums[i]>nums[i+1])
            {
                pos = i;
                temp = nums[i];
                nums[i] = nums[i + 1];
                nums[i + 1] = temp;
            }
        }
        k = pos;
    }
    print(nums);
}