现在排序方式有很多，掌握几种就可以了，当然了，冒泡排序是每个程序员必须要会的，快速排序怎么实现的，理论上也能说出一二，具体代码怎么实现，求各位大牛给出代码实现，简单易懂就行{:soso_e113:}，最好有注释啊

//每次用划分函数将数组划分为2部分，接下来递归对2部分进行快速排序。
//选这一段区间中的任意一个数为基准，进行元素交换，并找到一个下标，使下标左边的数都小于基准数，右边的都大于基准数。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = { 6, 2, 1, 7, 7, 1, 3, 7 };
            QuickSort(arr, 0, arr.Length - 1);
            foreach (int i in arr)
            Console.WriteLine(i);
            Console.ReadKey();
        }
        static int Partition(int[] arr, int l, int r)
        {
            int x = arr[l]; //基准值
            l--; r++;
            while (true)
            {
                do
                {
                    l++;
                }
                while (arr[l] < x); //自左向右找到一个不小于x的元素
                do
                {
                    r--;
                }
                while (arr[r] > x); //自右向左找到一个不大于x的元素
                if (l < r)  //没有找到划分界限之前
                {
                    //交换2个元素
                    int t = arr[l];
                    arr[l] = arr[r];
                    arr[r] = t;
                }
                else break; //找到界限了
            }
            return r;   //界限是r
        }

        static void QuickSort(int[] arr, int l, int r)
        {
            if (l < r)
            {
                int t = Partition(arr, l, r);
                QuickSort(arr, l, t);
                QuickSort(arr, t + 1, r);
            }
        }
    }
}

我来蹭一下。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace test
{
class Program
{
static void Main(string[] args)
{
int[] array = { 49, 38, 65, 97, 76, 13, 27 };
sort(array, 0, array.Length - 1);
Console.ReadLine();
}        /*        * 一次排序单元，完成此方法，key左边都比key小，key右边都比key大。
* @param array 排序数组
* @param low 排序起始位置
* @param high 排序结束位置
* @return 单元排序后的数组        */
private static int sortUnit(int[] array, int low, int high)
{
int key = array[low];
while (low < high)
{                //从后向前搜索比key小的值
while (array[high] >= key && high > low)
--high;                         //比key小的放左边
array[low] = array[high];           //从前向后搜索比key大的值，比key大的放右边
while (array[low] <= key && high > low)
++low;                              //比key大的放右边
array[high] = array[low];
}                                            //左边都比key小，右边都比key大。            //将key放在游标当前位置。            //此时low等于high
array[low] = key;
Console.WriteLine(array.ToString());
return high;
}        /*        * 快速排序        * @param arry        * @return        */
public static void sort(int[] array, int low, int high)
{
if (low >= high) return;                            //完成一次单元排序
int index = sortUnit(array, low, high);             //对左边单元进行排序
sort(array, low, index - 1);                        //对右边单元进行排序
sort(array, index + 1, high);        }
}
}

1. /// <summary>
   
2.         /// 升序快速排序
   
3.         /// </summary>
   
4.         /// <param name="ia"></param>ia 是要进行排序的数组，
   
5.         /// <param name="low"></param>
   
6.         /// <param name="high"></param>low和high分别记录数组中需要排序的的区间的下限索引和上限索引
   
7.         static void QuickSort(int[] ia, int low, int high)
   
8.         {
   
9.             int l = low, h = high; //将l，h记录low 和 high 后续中将会用到l 和 h游标
   
10.             int pos = l;    //pos 用来记录需要进行定位的元素的索引，初始化为l，即从最低索引开始定位；
    
11.             int temp = ia[l]; //temp用来记录定位元素的值，初始化为ia[l]；
    
12.             while (l != h) // 当l和h不相等时，意味着元素可能还没有定位成功
    
13.             {
    
14. 
    
15.                 while (h > l)//先在上游元素中进行定位，如果发现上游有比要定位元素值小的，进行换位。
    
16.                 {
    
17.                     if (temp > ia[h])
    
18.                     {
    
19.                         ia[l] = ia[h];
    
20.                         pos = h;
    
21.                         l++;
    
22.                         break;
    
23.                     }
    
24.                     h--;
    
25.                 }
    
26.                 while (l < h)//然后在下游元素中进行定位，如果发现下游中有比要定位元素大的，进行换位.
    
27.                 {
    
28.                     if (temp < ia[l])
    
29.                     {
    
30.                         ia[h] = ia[l];
    
31.                         h--;
    
32.                         pos = l;
    
33.                         break;
    
34.                     }
    
35.                     l++;
    
36.                 }
    
37. 
    
38.                 if (l == h) //如果l和h相等，意味着定位元素已经成功定位。
    
39.                 {
    
40.                     ia[pos] = temp;
    
41.                 }
    
42. 
    
43.             }
    
44. 
    
45.             if ((pos - 1) > low)//对定位的位置左边的区间进行递归
    
46.             {
    
47.                 QuickSort(ia, low, pos - 1);
    
48.             }
    
49. 
    
50.             if (pos + 1 < high)//对定位的位置右边的区间进行递归
    
51.             {
    
52.                 QuickSort(ia, pos + 1, high);
    
53.             }
    
54.             
    
55.         }

复制代码