Irene‘s 排序算法笔记

0.前言

        先来看下各个内部排序算法的复杂度和稳定性，图片来自菜鸟教程，代码使用C#。

        

 名词解释：
        稳定性：如果有一对相等的键值，排序后他们的前后关系不变，则是稳定的。
        outline：占用额外内存
        内部排序：数据记录在内存中排序
        外部排序：待排序的数量很大，无法一次性放到内存中排序，排序过程需要访问外存，常见的外部排序算法是归并排序。

1.冒泡排序

        算法老师教的第一个算法（笑），流程是遍历未排序的数列，依次比较两个数，如果顺序不对则发生交换，如果一轮遍历没有发生交换，则说明排序好了，直接跳出，当然这改进没什么太大作用。
        正序（已排序好）的时候最快，逆序最慢为O（N^2），是稳定的。
 

    void BubbleSort(int[] intArray)
        {
            int n = intArray.Length,temp = 0;
            bool swapped;   //如果一轮遍历没有发生交换，则说明已经排序好了，跳出
            for(int i = 0; i < n; ++i)
            {
                swapped = false;
                for(int j = 0; j < n - 1 - i; ++j)
                {
                    if (intArray[j] > intArray[j + 1])
                    {
                        temp = intArray[j];
                        intArray[j] = intArray[j + 1];
                        intArray[j + 1] = temp;
                        if (!swapped)
                            swapped = true;
                    }
                }
                if (!swapped)
                    return;
            }
        }

2.选择排序

        无论什么顺序的数组进去都是O（n）的时间复杂度，是不稳定的。流程为在未排序数列选择最小值，然后放到已排序数列末尾。

        void SelectedSort<T>(T[] Array) where T: System.IComparable<T>
        {
            int n = Array.Length,minIndex;
            T temp;
            for (int i = 0; i < n-1; ++i)
            {
                minIndex = i;
                for(int j = i+1; j < n; ++j)
                {
                    if (Array[minIndex].CompareTo(Array[j]) > 0)
                        minIndex = j;
                }
                temp = Array[minIndex];
                Array[minIndex] = Array[i];
                Array[i] = temp;
            }
        }

3.插入排序

        流程类似打扑克牌，一列已排序数列，一列未排序数列，从未排序数列中选第一个插入已排序数列。插入方法是在已排序数列从后开始比较，顺序不对就交换。 优化方法是拆半插入。
时间复杂度，在正序下为O（n），逆序下为O（n^2），是稳定的。

        void InsertSort(int[] intArray)
        {
            int temp;
            for(int i = 1; i < intArray.Length; i++)
            {
                temp = intArray[i];
                for(int j = i - 1; j >= 0; j--)
                {
                    if (intArray[j] > temp)
                    {
                        intArray[j + 1] = intArray[j];
                        intArray[j] = temp;
                    }
                    else
                    {
                        break;
                    }

                }
         

4.希尔排序

        希尔排序是看名字最不直观的排序算法了（笑）。
        希尔排序也成为递减增量排序，是插入排序的优化版本，但不稳定。那么对比插入排序，进行了什么优化呢：
        插入排序对几乎排序好的数据，效率高，几乎达到线性。但大部分情况是低效的，因为每次只能移动一位。
        希尔排序的时间复杂度和步长有关，正序最高O（n），逆序最低O（n^2），平均复杂度为
O（n^1.3）。
        流程是就整个待排序的数组分为几个子序列，分别进行插入排序。结束后差不多达到（几乎排序好），此时对整体使用插入排序。

<