基础为技术之本_冒泡，简单排序，简单插入排序汇总

八大排序算法可以说是最好理解以及嘴简单的排序了，回顾的时候就一起记一下：

简单选择排序：可以说是嘴接近人思维的思路，不用考虑机器累不累的一种方式。每一次都从数组中找到最小的元素与第一个元素交换，然后在从第二个元素以后选取最小的。

/// <summary>
    /// 简单选择排序
    /// </summary>
    /// <param name="array">要排序的数组</param>
    /// <param name="arrayLength">数组长度</param>
    public void SelectSimpleSort(int[] array)
    {
        if (array == null)
        {
            Console.WriteLine("Para Invaild");
            return;
        }
        int temp = 0;
        for (int i = 0; i < array.Length - 1; i++)
        {
            int minIndex = i;
            for (int j = i + 1; j < array.Length; ++j)
            {
                if(array[j] < array[minIndex])
                    minIndex = j;
            }
            temp = array[i];
            array[i] = array[minIndex];
            array[minIndex] = temp;
            temp = 0;
        }
    }

能看到无论如何都要执行内外两重循环，所以怎样时间复杂度都是O(n^2)，不需要额外空间，另外选择排序也是不稳定的，对于int这样的基本数据类型，稳定性基本上是没有意义的；

冒泡排序：冒泡排序就是若前面一个元素大于后面一个元素，则交换两个元素，这样可将整个序列中最大的元素冒泡到最后，就像汽水瓶里面的气泡一样，大的总是会最先附上去。

/// <summary>
    /// 冒泡排序
    /// </summary>
    /// <param name="array"></param>
    public void BubbleSort(int[] array)
    {
        int temp = 0;
        for (int i = 0; i < array.Length - 1; i++)
        {
            for (int j = 0; j < array.Length - 1 - i; ++j)
            {
                if (array[j] > array[j+1])
                {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    temp = 0;
                }
            }
        }
    }

冒泡排序与简单选择排序类似，无论如何都要执行完两重循环，故最好、最坏和平均时间复杂度均为O(n2)，不需要额外空间。冒泡排序是稳定的。

冒泡排序的一个改进是，在内层循环之前设置一个标记变量，用于标记循环是否进行了交换，在内层循环结束时，若判断没有进行交换，则说明剩下的序列中，每个元素都小于等于后面一个元素，即已经有序，可终止循环。这样，冒泡排序的最好时间复杂度可以提升到O(n)。加强版代码如下：

/// <summary>
    /// 冒泡排序加强版
    /// </summary>
    /// <param name="array"></param>
    public void BubbleSortPro(int[] array)
    {
        int temp = 0;
        bool hasChanged;
        for (int i = 0; i < array.Length - 1; i++)
        {
            hasChanged = false;
            for (int j = 0; j < array.Length - 1 - i; ++j)
            {
                if (array[j] > array[j + 1])
                {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    temp = 0;
                    hasChanged = true;
                }
            }
            if (!hasChanged)
                break;
        }
    }

简单插入排序：个人感觉有点类似于让我们把一副扑克牌整理好相应的顺序，从无序的扑克牌中一次一次的抽出我们需要的扑克牌放在新的有序的扑克牌中。

/// <summary>
    /// 简单插入排序
    /// </summary>
    /// <param name="array"></param>
    public void InsertSort(int[] array)
    {
        for (int i = 1; i < array.Length; i++)
        {
            int index = i - 1;
            int value = array[i];
            while (index >= 0 && array[index] >= value)
            {
                array[index + 1] = array[index];
                array[index] = value;
                index--;
            }
        }
    }

两重循环，最差和平均时间复杂度为O(n2)，最好情况是原序列已有序，则忽略内层循环，时间复杂度O(n)。插入排序是稳定的。

简单插入排序也是可以再优化的，我们可以使用二分查找来寻找插入位置，从而使时间复杂度提高到O(n*log n)。