排序算法1：快速排序

   今儿闲着，实现了下一维数组快速排序算法。

快速排序分三个步骤（参考维基百科：http://zh.wikipedia.org/wiki/%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F）：

1.选取一个基准值。（一般以第一个为基准）

2.重新排序，所有比基准小的都放在左边，所有比基准大的都放在右边。排序过后，该基准处于数列中间位置。（分治法中的分，以基准值为中心，分为左右两个分区）

3.递归的按照1、2两步骤排序左右两个分区。

 

控制台程序如下：

方法1：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            SortTest myTest = new SortTest();
            myTest.SetMyArray(10);
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(myTest.myArray[i]);
            }
            Console.WriteLine("快速排序");
            myTest.QuickSort(myTest.myArray,0,9);
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(myTest.myArray[i]);
            }
        }
    }

    class SortTest
    {
        public int[] myArray;

        /// <summary>
        /// 生成数组
        /// </summary>
        /// <param name="length"></param>
        public void SetMyArray(int length)
        {
            System.Random random = new Random();
            myArray = new int[length];
            for (int i = 0; i < length; i++)
            {
                myArray[i] = random.Next(100);
            }
        }

        /// <summary>
        /// 排序分割
        /// </summary>
        /// <param name="array"></param>
        /// <param name="low"></param>
        /// <param name="high"></param>
        /// <returns></returns>
        public int ReturnIndex(int[] array,int low,int high)
        {
            int xMark = array[low];
            while (low < high)
            {
                //从右往左
                while (array[high] > xMark && low < high)
                {
                    high--;
                }
                if (low < high)
                {
                    array[low] = array[high];
                    low++;
                }
                //从左往右
                while (array[low] < xMark && low < high)
                {
                    low++;
                }
                if (low < high)
                {
                    array[high] = array[low];
                    high--;
                }
            }
            array[low] = xMark;
            return low;
        }

        /// <summary>
        /// 快速排序
        /// </summary>
        /// <param name="array"></param>
        /// <param name="low"></param>
        /// <param name="high"></param>
        public void QuickSort(int[] array, int low, int high)
        {
            if (low < high)
            {
                int index = ReturnIndex(array, low, high);
                QuickSort(array, low, index - 1);//递归调用
                QuickSort(array, index + 1, high);
            }
        }
    }
}

 方法2：维基百科中的方法，比第一个简洁，看着舒服。

         public static void Sort(int[] numbers)
        {
            Sort(numbers, 0, numbers.Length - 1);
        }

        private static void Sort(int[] numbers, int left, int right)
        {
            if (left < right)
            {
                int middle = numbers[(left + right)/2];
                int i = left -1;
                int j = right +1;
                while (true)
                {
                    while (numbers[++i] < middle) ;
                    while (numbers[--j] > middle) ;
                    if (i >= j)
                        break;
                    Swap(numbers,i,j);
                }
                Sort(numbers, left, i-1);
                Sort(numbers, j+1, right); 
            }
        }

        private static void Swap(int[] numbers, int i, int j)
        {
            int number = numbers[i];
            numbers[i] = numbers[j];
            numbers[j] = number;
        }