排序算法

冒泡排序

冒泡排序是一种计算机科学领域中较简单的排序算法。它的工作原理是：重复地走访过要排序的元素，依次比较两个相邻的元素，如果顺序错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

排序步骤

1. 比较相邻元素。如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素做同样的工作，从开始的第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3. 针对所有的元素重复以上的步骤，除了最后一个。

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

时间复杂度

• 最好（正序）：O(n)
• 最坏（反序）：O(n^2)
• 平均时间复杂度：O(n^2)

算法稳定性：稳定

/// <summary>
        /// 冒泡排序   
        /// 1.比较相邻元素。如果第一个比第二个大，就交换他们两个。
        /// 2.对每一对相邻元素做同样的工作，从开始的第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 
        /// 3.针对所有的元素重复以上的步骤，除了最后一个。
        /// 4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
        /// 
        /// 时间复杂度：
        /// 正序：O(n)
        /// 反序：O(n^2)
        /// 平均时间复杂的：O(n^2)
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public static List<int> BubbleSort(List<int> list)
        {
            for (int i = 0; i < list.Count - 1; i++)
            {
                for (int j = 0; j < list.Count - 1 - i; j++)
                {
                    if (list[j] > list[j + 1])
                    {
                        int temp = list[j];
                        list[j] = list[j + 1];
                        list[j + 1] = temp;
                    }
                }
            }
            return list;
        }

选择排序

选择排序是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。

排序步骤

1. 从左至右遍历，找到最小(大)的元素，然后与第一个元素交换。

2. 从剩余未排序元素中继续寻找最小（大）元素，然后与第二个元素进行交换。

3. 以此类推，直到所有元素均排序完毕。

时间复杂度

• 最好：O(n^2)
• 最坏：O(n^2)

算法稳定性：不稳定

/// <summary>
        /// 选择排序
        /// 1. 从左至右遍历，找到最小(大)的元素，然后与第一个元素交换。
        /// 2. 从剩余未排序元素中继续寻找最小（大）元素，然后与第二个元素进行交换。
        /// 3. 以此类推，直到所有元素均排序完毕。
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public static List<int> SelectionSort(List<int> list)
        {
            for (int i = 0; i < list.Count; i++)
            {
                int min = i;

                for (int j = i + 1; j < list.Count; j++)
                {
                    if (list[min] > list[j]) min = j;
                }

                int temp = list[i];
                list[i] = list[min];
                list[min] = temp;
            }
            return list;
        }

插入排序

插入排序，一般也被称为直接插入排序。对于少量元素的排序，它是一个有效的算法 。插入排序是一种最简单的排序方法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增1的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动。

时间复杂度

• 最坏（正序）：O(n)
• 最坏（反序）：O(n^2)

空间复杂度：O(1)

算法稳定性：稳定

 /// <summary>
        /// 插入排序
        /// 1.从第一个元素开始，该元素可以认为已经被排序
        /// 2.取出下一个元素，在已经排序的元素序列中从后向前扫描
        /// 3.如果该元素小于前面的元素（已排序），则依次与前面元素进行比较如果小于则交换，直到找到大于该元素的就则停止；
        /// 4.如果该元素大于前面的元素（已排序），则重复步骤2
        /// 5.重复步骤2-4 直到所有元素都排好序 。
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public static List<int> InsertSort(List<int> list)
        {
            for (int i = 1; i < list.Count; i++)
            {
                for (int j = i; j > 0; j--)
                {
                    if (list[j] < list[j-1])
                    {
                        int temp = list[j - 1];
                        list[j - 1] = list[j];
                        list[j] = temp;
                    }
                    else
                    {
                        break;
                    }
                }
            }
            return list;
        }

快速排序

快速排序是对冒泡排序的一种改进。基本思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

排序流程

快速排序算法通过多次比较和交换来实现排序，其排序流程如下：

1.首先设定一个分界值，通过该分界值将数组分成左右两部分。

2.将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。

3.然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。

4.重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

排序步骤

设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它左边，所有比它大的数都放到它右边，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。

1.设置两个变量L、R，排序开始的时候：L=0，R=N-1；

2.以第一个数组元素作为关键数据，赋值给Key，即Key=A[0]；

3.从R前搜索，即由后开始向前搜索(R--)，找到第一个小于Key的值A[R]，将A[R]和A[L]的值交换；

4.从L开始向后搜索，即由前开始向后搜索(L++)，找到第一个大于Key的A[L]，将A[L]和A[R]的值交换；

5.重复第3-4步，直到L=R； (3,4步中，没找到符合条件的值，即3中A[R]不小于Key,4中A[L]不大于Key的时候改变R、L的值，使得R=R-1，L=L+1，直至找到为止。找到符合条件的值，进行交换的时候L，R指针位置不变。另外，L==R这一过程一定正好是L+或R-完成的时候，此时令循环结束）。

排序演示

假设一开始序列A是：5，3，7，6，4，1，0，2，9，10，8。

此时Key=5，L=1，R=11，从后往前找，第一个比5小的数是A8=2，因此序列为：2，3，7，6，4，1，0，5，9，10，8。

此时L=1，R=8，从前往后找，第一个比5大的数是A3=7，因此序列为：2，3，5，6，4，1，0，7，9，10，8。

此时L=3，R=8，从第8位往前找，第一个比5小的数是A7=0，因此：2，3，0，6，4，1，5，7，9，10，8。

此时L=3，R=7，从第3位往后找，第一个比5大的数是A4=6，因此：2，3，0，5，4，1，6，7，9，10，8。

此时L=4，R=7，从第7位往前找，第一个比5小的数是A6=1，因此：2，3，0，1，4，5，6，7，9，10，8。

此时L=4，R=6，从第4位往后找，直到第6位才有比5大的数，这时，L=R=6，Key成为一条分界线，它之前的数都比它小，之后的数都比它大，对于前后两部分数，可以采用同样的方法来排序。

代码示例

public static List<int> QuickSort(List<int> list, int left, int right)
        {
            if (left < right)
            {
                int L = left;
                int R = right;
                int Key = list[L];

                while (L < R)
                {
                    while (L < R)
                    {                       
                        if (list[R] >= Key)//从右往左找，找小于基准的数，如果该数大于等于基准，R--继续找
                        {
                            R--;
                        }
                        else
                        {
                            list[L] = list[R];
                            break;
                        }
                    }
                    while (L < R)
                    {                       
                        if (list[L] < Key)//从左往右找，找大于基准的数，如果该数小于基准，L++继续找
                        {
                            L++;
                        }
                        else
                        {
                            list[R] = list[L];
                            break;
                        }
                    }
                }
                list[L] = Key;
                QuickSort(list, left, L - 1);
                QuickSort(list, L + 1, right);
            }
            return list;
        }