c#的 排序算法--冒泡排序，快速排序

交换排序： 包括冒泡排序，快速排序。

  选择排序： 包括直接选择排序，堆排序。

  插入排序： 包括直接插入排序，希尔排序。

  合并排序： 合并排序。 

冒泡排序：比较第一个和第二个，后者小于前者两者交换，第二个比较第三个，第三个比较第四个，直到最后，然后重复该过程
9 8 7 6
8 9 7 6
8 7 9 6
8 7 6 9
7 8 6 9
7 6 8 9
6 7 8 9
over！

              int temp;
              int[] arrSort = new int[] { 10, 8, 3, 5, 6, 7, 9 };
            for (int i = 0; i < arrSort.Length; i++)
             {
                 for (int j = i + 1; j < arrSort.Length; j++)
                 {
                      if (arrSort[j] < arrSort[i])
                    {
                        temp = arrSort[j];                       
                       arrSort[j] = arrSort[i];
                      arrSort[i] = temp;

                    }
                 }
             }

冒泡排序为：O(n^2 )
若第二个循环改成 for (i = 0; i < arrSort.Length - 1; i++) 内循环次数高于冒泡排序

快速排序，效率比冒泡排序高

1）、设置两个变量I、J，排序开始的时候I：=1，J：=N；

2）以第一个数组元素作为关键数据，赋值给X，即X：=A[1]；

3）、从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，两者交换；

4）、从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，两者交换；

5）、重复第3、4步，直到I=J；

49 38 65 97 76 13 27
I=1 J=7 X =49
从后往前找小于的，并交换位置
27 38 65 97 76 13 49
J = 7 I = 1
从前往后找大于的，并 交换位置
27 38 49 97 76 13 65
I = 3,J =7
从后往前找小于的，并交换位置
27 38 13 97 76 49 65
J = 6, I=3
从前往后找大于的，并交换位置
27 38 13 49 76 97 65
I =6, J =6
第一次排序完成

{27，38，13}49{76，97，65}

再重复上述顺序，直到每个集合元素为1
{27 38 13 } { 76 97 65}
{13 38 27 } { 65 97 76}
{13 27 38 } { 65 76 97}
再重复上述顺序，直到每个集合元素为1

private void QuickSort(List<int> arr, int left, int right)  
   {  
       if (left < right)  
       {  
           int index = (left + right)/2;//取中间的数的下角标   
           int key = arr[index]; //取中间的数，作为对照数  
           int i = left;  
           int j = right;  
           while (true)  
           {  
               while (arr[i] <= key && i != index) //一直循环直到碰到第一个小于对照数时跳出循环,并且判断是否是相同的数，防止死循环 （去除对照数，防止把对照数当做相同的数出现运算错误）  
               {  
                   i++;  
               }  
               while (arr[j] > key)//同上，碰到第一个大于对照数跳出    
               {  
                   j--;  
               }  
               if (i >= j)//如果前面的位置大于后面的证明数组循环一遍了，跳出循环    
               {  
                   break;  

               }  
               swap(arr, i, j);  
           }  
           QuickSort(arr, left, i);  
           QuickSort(arr, i + 1, right);  
       }  
   }  

   private void swap(List<int> arr, int i, int j)  
   {  
       int temp = arr[i];  
       arr[i] = arr[j];  
       arr[j] = temp;  
   }