常见的排序算法

 //简单的交换排序（假性冒泡排序），效率低下, 会将较小的记录移动到最后
        static void BubbleSort_Verson1(List<int> list)
        {
            int tempVal = 0;
            for (int i = 0, iMax = list.Count; i < iMax; ++i)
            {
                for (int j = i + 1, jMax = list.Count; j < jMax; j++)
                {
                    if (list[i] > list[j])
                    {
                        tempVal = list[i] + list[j];
                        list[i] = tempVal - list[i];
                        list[j] = tempVal - list[i];
                    }
                }
            }
        }

   static void BubbleSort_Version2(List<int> list)
        {
            int temp = 0;
            for (int i = 0, iMax = list.Count - 1; i < iMax; ++i)
            {
                for (int j = 0, jMax = list.Count - 1 - i; j < jMax; ++j)
                {
                    if (list[j] > list[j + 1])
                    {
                        temp = list[j] + list[j + 1];
                        list[j] = temp - list[j];
                        list[j + 1] = temp - list[j];
                    }
                }
            }
        }

 //冒泡排序优化:如果list中的元素大部分都是有序的，在不优化的情况下，会做无意义的比较，这样优化后可以避免该问题
        static void BubbleSort_Version3(List<int> list)
        {
            int temp = 0;
            bool flag = true;   //冒泡优化
            for (int i = 0, iMax = list.Count - 1; i < iMax && flag; ++i)
            {
                flag = false;
                for (int j = 0, jMax = list.Count - 1 - i; j < jMax; ++j)
                {
                    if (list[j] > list[j + 1])
                    {
                        temp = list[j] + list[j + 1];
                        list[j] = temp - list[j];
                        list[j + 1] = temp - list[j];
                        flag = true;
                    }
                }
            }
        }

static void SimpleSelectSort(List<int> list)
        {
            int minIndex, tempVal;
            for (int i = 0, iMax = list.Count - 1; i < iMax; ++i)
            {
                minIndex = i;
                for (int j = i + 1, jMax = list.Count; j < jMax; ++j)
                {
                    if (list[j] < list[minIndex])
                        minIndex = j;
                }

                if (minIndex != i)
                {
                    tempVal = list[minIndex] + list[i];
                    list[i] = tempVal - list[i];
                    list[minIndex] = tempVal - list[i];
                }
            }
        }

 1   //直接插入排序:将一个无序表中的记录插入一个已经排好序的有序表中，指导插入完为止
 2         static void InsertSort(List<int> list)
 3         {
 4             int i, iMax, j, tempVal;
 5 
 6             //i=1 开始，是因为初始假设数组第 0 位组成一个有序数组
 7             for (i = 1, iMax = list.Count; i < iMax; ++i)
 8             {
 9                 //找出无需数组的中比有序数组中的最后一位小的记录，进行插入
10                 if (list[i] < list[i - 1])
11                 {
12                     //存储要放入的记录，防止数据丢失
13                     tempVal = list[i];
14 
15                     //将有序数组从第 i-1（相对于整个数组） 开始，依次后移一位（之所以可以后移，因为 tempVal 保留了第 i 位置的，从而提供出一个空位）， 即寻找合适的插入位置
16                     for (j = i - 1; j >= 0 && list[j] > tempVal; --j)
17                         list[j + 1] = list[j];
18 
19                     list[j + 1] = tempVal;  //将保存的记录插入合适的找寻出的位置
20                 }
21             }
22         }