数据结构 --- 排序

1、稳定排序和不稳定排序

　　相等的两个元素在排序前后的相对位置不发生变化称之为稳定排序，否则，是不稳定排序。

2、内排序和外排序

　    排序的过程中，待排序的记录全部在内存中称之为内排序，否则称之为外排序。

　　而数据结构中涉及的排序基本都指内排序。

3、影响内排序性能的主要因素：

　　时间性能、辅助空间、算法本身的复杂度

4、主要分类：

　　插入排序、交换排序、选择排序、归并排序

5、按照算法的复杂度分为两大类：

　　简单算法---冒泡排序、简单选择排序、直接插入排序

　　改进算法---希尔排序、堆排序、归并排序、快速排序

using System;
using System.Collections;
using System.Collections.Generic;

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> list = new List<int> { 12, 0, 5, 6, 41, -5 };

            QuickSort(list, 0, list.Count - 1);

            for (int i = 0; i < list.Count - 1; i++)
                Console.WriteLine(list[i]);

            Console.ReadKey();
        }

        //冒泡排序(Bubble Sort):
        //它会遍历若干次要排序的数列，每次遍历时，它都会从前往后依次的比较相邻两个数的大小；
        //如果前者比后者大，则交换它们的位置。这样，一次遍历之后，最大的元素就在数列的末尾！
        //采用相同的方法再次遍历时，第二大的元素就被排列在最大元素之前。重复此操作，直到整个数列都有序为止！
        static void BubbleSort(List<int> list)
        {
            int i, j;
            bool isBreak = false;
            for (i = list.Count - 1; i > 0; --i)
            {
                isBreak = true;
                for (j = 0; j < i; ++j)
                {
                    if (list[j] > list[j + 1])
                    {
                        isBreak = false;
                        int temp = list[j] + list[j + 1];
                        list[j] = temp - list[j];
                        list[j + 1] = temp - list[j];
                    }
                }

                if (isBreak)
                    break;
            }
        }

        //直接插入排序(Straight Insertion Sort):
        //把n个待排序的元素看成为一个有序表和一个无序表。开始时有序表中只包含1个元素，
        //无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，将它插入到有序表中的适当位置，
        //使之成为新的有序表，重复n-1次可完成排序过程。
        static void StraightInsertSort(List<int> list)
        {
            int i, j, k;
            int iMax = list.Count - 1;

            for (i = 1; i <= iMax; ++i)
            {
                //查找合适的插入位置
                for (j = i - 1; j >= 0; --j)
                {
                    if (list[j] < list[i])
                        break;
                }

                //如果找到了一个合适的位置
                if (j != i - 1)
                {
                    //移动i位置之前，j位置之后的元素
                    int temp = list[i];
                    for (k = i - 1; k > j; --k)
                        list[k + 1] = list[k];

                    //将i位置的元素插入寻得的合适位置，思考为什么是 j+1
                    list[j + 1] = temp;
                }
            }
        }

        //选择排序(Selection sort)是一种简单直观的排序算法。
        //首先在未排序的数列中找到最小(or最大)元素，然后将其存放到数列的起始位置；
        //再从剩余未排序的元素中继续寻找最小(or最大)元素，然后放到已排序序列的末尾。
        //以此类推，直到所有元素均排序完毕。
        static void SelectionSort(List<int> list)
        {
            int i, j, min;
            int count = list.Count;
            for (i = 0; i < count; ++i)
            {
                min = i;

                for (j = i + 1; j < count; ++j)
                {
                    if (list[j] < list[min])
                        min = j;
                }

                if (min != i)
                {
                    int temp = list[min] + list[i];
                    list[i] = temp - list[i];
                    list[min] = temp - list[i];
                }
            }
        }

        //快速排序(Quick Sort)使用分治法策略。
        //它的基本思想是：选择一个基准数，通过一趟排序将要排序的数据分割成独立的两部分；其中一部分的所有数据都比另外一部分的所有数据都要小。
        //再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
        //快速排序流程：
        //(1) 从数列中挑出一个基准值。
        //(2) 将所有比基准值小的摆放在基准前面，所有比基准值大的摆在基准的后面(相同的数可以到任一边)；在这个分区退出之后，该基准就处于数列的中间位置。
        //(3) 递归地把"基准值前面的子数列"和"基准值后面的子数列"进行排序。
        static void QuickSort(List<int> list, int lBorder, int rBorder)
        {
            if (lBorder < rBorder)
            {
                int i, j, temp;
                i = lBorder;
                j = rBorder;

                temp = list[i];  //相当于腾出一个位置
                while (i < j)
                {
                    //从右向左寻找第一个小于 temp 的值                    
                    while (i < j && list[j] > temp)
                        --j;
                    if (i < j)
                    {
                        list[i] = list[j];
                        ++i;
                    }


                    //从左向右寻找第一个大于 temp 的值
                    while (i < j && list[i] < temp)
                        ++i;
                    if (i < j)
                    {
                        list[j] = list[i];
                        --j;
                    }
                }

                list[i] = temp;

                QuickSort(list, lBorder, i - 1);
                QuickSort(list, i + 1, rBorder);
            }
        }
    }
}