C#常用的几种算法

      static void Swap(List<int>list,int i,int j)
        {
            int temp = list[i];


            list[i] = list[j];


            list[j] = temp;

        }

        #region (冒泡排序:基本思想-两两比较相邻记录的关键字，如果反序则交换，直到没有反序的的记录为止)
        static void BubbleSort(List<int>list)
        {
            for (int i = 0; i < list.Count - 1; i++)
            {
                for (int j = list.Count - 1; j > i; j--)
                {
                    if (list[j]<list[j-1])
                    {
                        Swap(list,j,j-1);
                    }
                }
            }
        }
        #endregion


        #region  (简单选择排序：基本思想-通过n-i次关键字的比较，从n-i+1个记录中选出关键字最小的记录，并和第i个记录交换)
        static void SelectSort(List<int>list)
        {
            for (int i = 0; i < list.Count -1; i++)
            {
                int temp = i;


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


                if (temp != i)
                {
                    Swap(list,temp,i);
                }
            }
        }


        #endregion


        #region (直接插入排序：基本思想-将一个记录插入到已经排好序的有序表中，从而得到一个新的，记录数增1的有序表)
        static void InSertSort(List<int> list)
        {
            for (int i = 1; i < list.Count; i++)
            {
                if (list[i]<list[i -1])
                {
                    int temp = list[i];


                    for (int j = i - 1; j>=0&& temp<list[j]; j--)
                    {
                        list[j + 1] = list[j];


                        list[j] = temp;
                    }
                }
            }
        }
        #endregion


        #region (希尔排序：基本思想-先取一个小于n的整数d1作为一个增量，把数组中的元素以下标间隔为d1分组，先在各组内进行直接插入排序，然后取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dx = 1，即所有记录放入到同一组中为止。一般的初次取序列的一半为增量，以后每次减半，直到增量为1)
        static void ShellSort(List<int>list)
        {
            int step = list.Count;


            do
            {
                step = step / 3 + 1;


                for (int i = step; i <list.Count; i++)
                {
                    int temp = 0;


                    if (list[i]< list[i - step])
                    {
                        temp = list[i];


                        for (int j = i - step; j >=0 && temp < list[j]; j -=step)
                        {
                            list[j + step] = list[j];


                            list[j] = temp;
                        }
                    }
                }
            }
            while (step>1);

        }


      static  void ShellSort(List<int> list, int n)
        {
            int d = n / 2;                   //设置起始增量
            while (d >= 1)
            {               //增量为1时排序结束
                for (int k = 0; k < d; k++)
                {    //遍历所有的子序
                    for (int i = k + d; i < n; i += d)
                    {  //对每个子序进行插入排序
                        int temp = list[i];   
                        int j = i - d;
                        while (j >= k && list[j] > temp)
                        {
                            list[j + d] = list[j];
                            j = j - d;
                        }
                        list[j + d] = temp;
                    }
                }
                d = d / 2;                   //缩小增量
            }
        }
        #endregion


        #region (快速排序：基本思想-通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的)
        static void QuickSort(List<int>list)
        {
            QSort(list, 0, list.Count-1);
        }


        static void QSort(List<int> list, int low, int high)
        {
            int pivot = 0;


            if (low<high)
            {
                pivot = Partition(list, low, high);


                QSort(list, low, pivot - 1);


                QSort(list, pivot + 1,high);


            }
        }


        static int Partition(List<int>list,int low,int high)
        {
            int povit =0;


            povit = list[low];


            while (low<high)
            {
                while (low < high && list[high]>=povit)
                {
                    high--;
                }


               list[low] = list[high];


                while (low < high && list[low] <= povit)
                {
                    low++;
                }


                list[high] = list[low];
            }


            list[low] = povit;


            return low;
        }
        #endregion