/// <summary>
        /// /找到一个数据序列中最大的数
        /// </summary>
        /// <param name="myArray">输入的整数序列</param>
        /// <returns>数据序列中最大的整数</returns>
        private static int FindMax(int [] myArray)
        {
            int max = myArray[0];

for(int i=1; i<myArray.Length; i++)
            {
                if( max < myArray[i] )
                    max = myArray[i];
            }

return max;
        }

        /// <summary>
        /// 取得一个整数的位数。比如123， 返回3。
        /// 利用整数除法的性质，不停地用10除以整数。
        /// 比如：123/10 = 12，12/10 = 1，1/10 = 0。
        /// 一共除了3次，那么就是一个3位数。
        /// </summary>
        /// <param name="number">输入的整数</param>
        /// <returns>数字的位数，比如123 返回 3</returns>
        private static int DigitNumber(int number)
        {
            int digit = 0;

do 
            {
                number /= 10;
                digit++;
            } while( number != 0 );

return digit;
        }

        /// <summary>
        /// 得到一个整数的某一位数，0表示个位数，1表示十位数
        /// 2表示百位数，等等。
        /// 利用的算法是求余。比如12/1 = 12，12%10 = 2，2就是个位数
        /// 12/10 = 1，1%10 = 1，1就是十位数，那么可以得到一个简单的公司
        /// 令n=n/(10^kth)，那么n%10就是所要求的位数
        /// </summary>
        /// <param name="number">输入的整数</param>
        /// <param name="kth">某位数字，0表示个位，1十位，2百位，依此类推</param>
        /// <returns>返回第k位数字</returns>
        private static int KthDigit(int number, int Kth)
        {
                number /=  (int)Math.Pow(10, Kth);

return number % 10;
        }

        /// <summary>
        /// 基数排序的中心思想就是将数字按照个位，十位，百位.分别排好序
        /// 那么整个数组也就有序了。
        /// 比如我们先将数组安装个位数字进行排序，然后再将这个数组安装十位排序
        /// 依次下去，我们就可以将整个数组进行排序
        /// </summary>
        /// <param name="myArray">输入的未排序数列</param>
        public static void RadixSort(int [] myArray)
        {
            int [] count = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
            int[,] temp = new int[10, myArray.Length];

int max = FindMax( myArray );                      //取得序列中的最大整数
            int maxDigit = DigitNumber( max );              //得到最大整数的位数

int i, j, k;
            for(i=0; i<maxDigit; i++)
            {
                for(j=0; j<10; j++)
                    count[j] = 0;

for(j=0; j<myArray.Length; j++)
                {
                    int xx = KthDigit( myArray[j], i );             //将数据安装位数放入到暂存数组中
                    temp[xx,count[xx]] = myArray[j];
                    count[xx] = count[xx] + 1;
                }

int index = 0;
                for(j=0; j<10; j++)                                    //将数据从暂存数组中取回，放入原始数组中
                {
                    for(k=0; k<count[j]; k++)
                    {
                        myArray[index] = temp[j,k];
                        index++;
                    }
                }
            }
        }

        /// <summary>
        /// Shell排序的中心思想是将数据进行分组，然后对每一组数据进行排序，
        /// 在每一组数据都有序之后，就可以对所有的分组利用插入排序进行最后一次排序
        /// 这样可以显著减少数据交换的次数，以达到加快排序速度的目的。
        /// </summary>
        /// <param name="myArray">输入的待排序序列</param>
        public static void ShellSort(int [] myArray)
        {
            int i, j, increment;
            int temp;

for( increment = myArray.Length / 2; increment > 0; increment /= 2 )
            {
                for( i = increment; i < myArray.Length; i++ )
                {
                    temp = myArray[i];

for( j = i; j >= increment; j -= increment )
                    {
                        if( temp < myArray[j-increment] )
                            myArray[j] = myArray[j-increment];
                        else
                            break;
                    }
                    myArray[j] = temp;
                }
            }
        }

        /// <summary>
        /// Shell排序的中心思想是将数据进行分组，然后对每一组数据进行排序，
        /// 在每一组数据都有序之后，就可以对所有的分组利用插入排序进行最后一次排序
        /// 这样可以显著减少数据交换的次数，以达到加快排序速度的目的。
        /// 新的算法将增量固定为3，也就是满足了D.E.Knuth的h(m+1)=3h(m)+1，h(1)=1
        /// </summary>
        /// <param name="myArray">输入的待排序序列</param>
        public static void ShellSort( int [] myArray )
        {
            int i, j, increment, temp;

increment = 3;

while( increment > 0 )
            {
                for( i=0; i < myArray.Length; i++ )
                {
                    j = i;
                    temp = myArray[i];

while( (j >= increment) && (myArray[j-increment] > temp) )
                    {
                        myArray[j] = myArray[j - increment];
                        j = j - increment;
                    }

myArray[j] = temp;
                }

if( increment/2 != 0 )
                {
                    increment = increment/2;
                }
                else if( increment == 1 )
                {
                    increment = 0;
                }
                else
                {
                    increment = 1;
                }
            }
        }

    public class QuickSorter
    {
        private static int[] myArray;
        private static int arraySize;

public static void Sort( int[] a )
        {
            myArray = a;
            arraySize = myArray.Length;
            QuickSort();
        }

/// <summary>
        ///     快速排序可以用递归的办法来设计程序。其基本思想如下：
        ///     首先，找到一个基准的数据，是数据右边的数都比它小，左边都比它
        ///     大，然后用这个基准将所有数据分成两部分，再对每一部分使用同样
        ///     的算法。
        ///     如何找到基准数据呢？从第0个数据开始，从数据的右端向左寻找比它大的数，
        ///     同时从数据的左端向右寻找比它小的数，然后交换两个数，这样一直找下去
        ///     直到左端数据的索引大于右端的数据索引，然后将第0个数和左端的数据索引交换
        ///     这样就得到了数据右边的数都比它小，左边的都比它大。
        private static void QuickSort()
        {
            QSort( 0, arraySize - 1);
        }

private static void QSort(int left, int right)
        {
            int pivot, l_hold, r_hold;

l_hold = left;
            r_hold = right;
            pivot = myArray[left];
            while (left < right)
            {
                //从右向左找小于pivot的值，然后将它和左边的值交换，直到
                //相遇为止
                while ((myArray[right] >= pivot) && (left < right)) 
                    right--;
                if (left != right)
                {
                    myArray[left] = myArray[right];
                    left++;
                }
                //从左向右找大于pivot的值，然后将它和右边的值交换，直到
                //相遇为止
                while ((myArray[left] <= pivot) && (left < right))
                    left++;
                if (left != right)
                {
                    myArray[right] = myArray[left];
                    right--;
                }
            }
            //将pivot放在中间，现在左边的值都小于pivot，右边的值都大于pivot
            myArray[left] = pivot;
            pivot = left;
            left = l_hold;
            right = r_hold;
            //递归，直到最后一个元素
            if (left < pivot)
                QSort(left, pivot-1);
            if (right > pivot)
                QSort( pivot+1, right);
        }
    }

QuickSorter.Sort( myArray );