快速排序算法。

http://www.cnblogs.com/huankfy/articles/1446588.html

 1    /* 快速排序
 2    ** 作者：huankfy
 3    ** 时间：2009-04-29
 4    */
 5    public class MyQuickSort
 6    {
 7        int[] data = new int[] { 10, 2, 5, 7, 3, 1, 20, 34, 4, 6, 30, 100, 23, 8 };
 8
 9
10        public void Display()
11        {
12            Sort(data, 0, data.Length - 1);
13            Console.WriteLine("快速排序结果为：");
14            for (int i = 0; i < data.Length; i++)
15                Console.WriteLine(data[i]);
16        }
17
18        private void Sort(int[] a, int left, int right)
19        {
20            if (left < right)
21            {
22                int i = Partition(a, left, right);
23                Sort(a, left, i - 1);
24                Sort(a, i + 1, right);
25            }
26        }
27
28        private int Partition(int[] a, int left, int right)
29        {
30
31            int tmp = a[left];
32            while (left < right)
33            {
34                while (left < right && a[right] >= tmp)
35                    right--;
36                
37                // 换位后不能将left+1,防止跳位
38                if(left<right)
39                    a[left] = a[right];
40
41                while (left < right && a[left] <= tmp)
42                    left++;
43
44                if (left < right)
45                {
46                    a[right] = a[left];
47                    // 有left < right，可将right向前推一位
48                    right--;
49                }
50            }
51
52            a[left] = tmp;
53
54            return left;
55        }
56
57    }

　　

http://www.cnblogs.com/zhujian198/archive/2008/05/13/1195016.html

using System;
/*
作者:朱剑
描写：C#实现快速排序算法
创建日期：2006/05/08
*/
namespace ConsoleApplication1
{
    class DataStructDemo
    {
        static void swap(ref int a,ref int b)
        {
            int temp;
            temp=a;
            a=b;
            b=temp;
        }
        static void sort(int[] arr,int left,int right)
        {
            int i,j,s;

            if(left < right)
            {
                i=left - 1;
                j=right + 1;
                s=arr[(i + j) / 2];
                while(true)
                {
                    while(arr[++i]<s);
                    while(arr[--j]>s);
                    if(i>=j)
                        break;
                    swap(ref arr[i],ref arr[j]);
                }
                sort(arr,left,i-1);
                sort(arr,j+1,right);
            }
        }
            [STAThread]
        static void Main(string[] args)
        {
                int[] arr={2,4,65,76,87,90,56,89,78};
                sort(arr,0,arr.Length-1);
                 Console.WriteLine("            Quick Sort Test!!!");
                for(int i=0;i<arr.Length;i++)
                {
                    Console.WriteLine(arr[i]);
                }
        }
    }
}

　　

 public static void Test快速排序()
        {
            var list = new List<int>() { 10,20,22,1,13,7,50,42,31,66,14};
            // QuickSort(ref list, 0, list.Count);
            Sort1(list, 0, list.Count);
        }

        public static void Sort1(List<int> list,int left ,int right)
        {
            if (left < right)
            {
                var i = left;
                var j = right - 1;
                var num = list[(left + right) / 2];
                while (true)
                {
                    while (list[i] < num)
                    {
                        i++;
                    };
                    while (j>0&&list[j] > num)
                    {
                        j--;
                    }
                    if (i >= j)
                        break;
                    var a = list[i];
                    list[i] = list[j];
                    list[j] = a;
                }
                Sort1(list, left, i);
                Sort1(list, i + 1, right);
            }
        }

2种算法实现有细微的区别，第二个好理解一点，主要用到递归，不过整体思路是

1，找最中间数做基准，

2，从后往前找到第一个小于基准的索引

3，从前往后找到第一个大于基准的索引

4，交换2，3值的位置。

5，从2继续向前找，从3继续向后找，各自找到第一个，交换位置，直到找到最中间

6，从最中间位置分成A,B2部分，再分别执行1-5的步骤

 es6中的变量交换

let x = 1;
let y = 2;
[x, y] = [y, x];