C#的排序算法以及随机产生不重复数字的几个Demo

今天无意看到以前写过的排序算法，顺便又想到随机产生不重复数字的这样一个要求的Demo（经常看到这样一道题目：产生一个int数组，长度为100，并向其中随机插入1-100，并且不能重复。），于是乎就写了一个，不借助于任何集合类，其思想无非就是排序算法的逆向操作。另外顺便把排序算法也粘贴出来。

class Program
    {
        static void Main(string[] args)
        {
            int[] array = RandomNotRepeatNum(100, 1);
            foreach (int item in array)
            {
                Console.WriteLine(item);
            }

            //int[] array = GetRandomNum(100, 1000);
            //foreach (int item in array)
            //{
            //    Console.WriteLine(item);
            //}
            //Console.WriteLine("排序后");
            //array = SortShell(array);
            //foreach (int item in array)
            //{
            //    Console.WriteLine(item);
            //}
            Console.ReadLine();
        }

        /// <summary>
        /// 随机获取数字
        /// </summary>
        /// <param name="count">获取到的数字的个数</param>
        /// <param name="max">获取的数字的最大值</param>
        /// <returns></returns>
        static int[] GetRandomNum(int count, int max)
        {
            if (count <= 0)
                return null;

            int[] array = new int[count];

            Random random = new Random();
            for (int i = 0; i < count; i++)
            {
                array[i] = random.Next(max);
            }

            return array;
        }

        /// <summary>
        /// 随机产生不重复数字
        /// </summary>
        /// <param name="max"></param>
        /// <param name="min"></param>
        /// <returns></returns>
        static int[] RandomNotRepeatNum(int max, int min)
        {
            int count = max - min + 1;
            int[] array = new int[count];

            for (int i = 0; i < count; i++)
            {
                array[i] = min;
                min++;
            }

            Random random = new Random();
            for (int i = 0; i < count; i++)
            {
                int temp = random.Next(count);
                int temp2 = 0;
                temp2 = array[temp];
                array[temp] = array[i];
                array[i] = temp2;
            }

            return array;
        }

        /// <summary>
        /// 冒泡排序：依次比较相邻的两个数，将小数放在前面，大数放在后面。编程复杂度低，稳定性。
        /// </summary>
        /// <param name="sortArray"></param>
        /// <returns></returns>
        static int[] SortBubble(int[] sortArray)
        {
            if (sortArray == null || sortArray.Length < 2)
            {
                return sortArray;
            }

            int i, j = 1, temp;
            bool done = false;
            while (!done && j < sortArray.Length)
            {
                done = true;
                for (i = 0; i < sortArray.Length - 1; i++)
                {
                    if (sortArray[i] > sortArray[i + 1])
                    {
                        done = false;
                        temp = sortArray[i];
                        sortArray[i] = sortArray[i + 1];
                        sortArray[i + 1] = temp;
                    }
                }
                j++;
            }
            return sortArray;
        }

        /// <summary>
        /// 选择排序：首先在未排序序列中找到最小元素，存放到排序序列的起始位置，
        /// 然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。
        /// 以此类推，直到所有元素均排序完毕
        /// </summary>
        /// <param name="sortArray"></param>
        /// <returns></returns>
        static int[] SortSelection(int[] sortArray)
        {
            if (sortArray == null || sortArray.Length < 2)
            {
                return sortArray;
            }

            int i, j = 0, min, temp;
            while (j < sortArray.Length - 1)
            {
                min = j;
                for (i = j + 1; i < sortArray.Length; i++)
                {
                    if (sortArray[i] < sortArray[min])
                    {
                        min = i;
                    }
                }
                temp = sortArray[min];
                sortArray[min] = sortArray[j];
                sortArray[j] = temp;
                j++;
            }

            return sortArray;
        }

        /// <summary>
        /// 插入排序：每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子文件中的适当位置，
        /// 直到全部记录插入完成为止。
        /// </summary>
        /// <param name="sortArray"></param>
        /// <returns></returns>
        static int[] SortInsert(int[] sortArray)
        {
            if (sortArray == null || sortArray.Length < 2)
            {
                return sortArray;
            }
            int i, j, temp;
            for (i = 1; i < sortArray.Length; i++)
            {
                temp = sortArray[i];
                j = i;
                while (j > 0 && temp < sortArray[j - 1])
                {
                    sortArray[j] = sortArray[j - 1];
                    j--;
                }
                sortArray[j] = temp;
            }
            return sortArray;
        }

        /// <summary>
        /// 希尔排序：将数组列在一个表中并对列排序（用插入排序）。
        /// 重复这过程，不过每次用更长的列来进行。
        /// 最后整个表就只有一列了，最后再进行插入排序。
        /// </summary>
        /// <param name="sortArray"></param>
        /// <returns></returns>
        static int[] SortShell(int[] sortArray)
        {
            if (sortArray == null || sortArray.Length < 2)
            {
                return sortArray;
            }

            int inc;
            for (inc = 1; inc <= sortArray.Length / 9; inc = 3 * inc + 1) ;
            for (; inc > 0; inc /= 3)
            {
                for (int i = inc + 1; i <= sortArray.Length; i += inc)
                {
                    int t = sortArray[i - 1];
                    int j = i;
                    while ((j > inc) && (sortArray[j - inc - 1] > t))
                    {
                        sortArray[j - 1] = sortArray[j - inc - 1];
                        j -= inc;
                    }
                    sortArray[j - 1] = t;
                }
            }
            return sortArray;
        }
    }