冒泡排序，选择排序，插入排序，快速排序

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

namespace TestSample
{

    #region explaination


    //一、冒泡排序 

    //已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不变。再比较a[2]与a[3]的值，若a[2]大于a[3]则交换两者的值，否则不变。再比较a[3]与a[4]，依此类推，最后比较a[n-1]与a[n]的值。这样处理一轮后，a[n]的值一定是这组数据中最大的。再对a[1]~a[n-1]以相同方法处理一轮，则a[n-1]的值一定是a[1]~a[n-1]中最大的。再对a[1]~a[n-2]以相同方法处理一轮，依此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升序排列了。 
    
    //优点：稳定，比较次数已知； 它的时间复杂度为O（n^2）

    //缺点：慢，每次只能移动相邻两个数据，移动数据的次数多。 


    //二、选择排序 

    //已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不变。再比较a[1]与a[3]的值，若a[1]大于a[3]则交换两者的值，否则不变。再比较a[1]与a[4]，依此类推，最后比较a[1]与a[n]的值。这样处理一轮后，a[1]的值一定是这组数据中最小的。再将a[2]与a[3]~a[n]以相同方法比较一轮，则a[2]的值一定是a[2]~a[n]中最小的。再将a[3]与a[4]~a[n]以相同方法比较一轮，依此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升序排列了。 
    //总是假设a【a1】最小
    //每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法

    //优点：不稳定，比较次数与冒泡排序一样，数据移动次数比冒泡排序少； 它的时间复杂度为O（n^2）

    //缺点：相对之下还是慢。 

    //三、插入排序 

    //假定这个数组的序是排好的，然后从头往后，如果有数比当前外层元素的值大，则将这个数的位置往后挪，直到当前外层元素的值大于或等于它前面的位置为止.这具算法在排完前k个数之后，可以保证a[1…k]是局部有序的，保证了插入过程的正确性.

    //优点：稳定，快；  O(n^2)

    //缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决这个问题。 

    //四、缩小增量排序 

    //由希尔在1959年提出，又称希尔排序。 

    //已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。发现当n不大是，插入排序的效果很好。首先取一增量d(d <n)，将a[1]、a[1+d]、a[1+2d]……列为第一组，a[2]、a[2+d]、a[2+2d]……列为第二组……，a[d]、a[2d]、a[3d]……列为最后一组依此类推，在各组内用插入排序，然后取d' <d，重复上述操作，直到d=1。 

    //优点：快，数据移动少； 

    //缺点：不稳定，d的取值是多少，应取多少个不同的值，都无法确切知道，只能凭经验来取。 

    //五、快速排序 

    //快速排序是冒泡排序的改进版，是目前已知的最快的排序方法。 

    //设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。

    //优点：极快，数据移动少；O(nlog n) 期望时间，O(n^2) 最坏情况 

    //缺点：不稳定。 

    #endregion

    class Program
    {
        /// <summary>
        /// bubble sort
        /// </summary>
        /// <param name="array"></param>
        static void Bsort(int[] array)
        {
            //int[] bsort = { 12, 35, 11, 67, 34, 89, 99, 23 };
            for (int i = 0; i < array.Length; i++)
            {
                for (int j = i + 1; j < array.Length; j++)
                {
                    if (array[j] < array[i])
                    {
                        int temp;
                        temp = array[j];
                        array[j] = array[i];
                        array[i] = temp;

                    }
                }
            }
            Console.WriteLine("after the bubble sort, the array as below:");
            for (int i = 0; i < array.Length; i++)
            {
                Console.Write(array[i] + " ");
            }
 
        }

        /// <summary>
        /// select sort
        /// </summary>
        /// <param name="array"></param>
        static void SelectSort(int[] array)
        {
            for (int i = 0; i < array.Length; i++)
            {
                int temp;
                int min = array[i];
                for (int j = i + 1; j < array.Length; j++)
                {
                    if (min > array[j])
                    {
                        min = array[j];
                        temp = array[i];
                        array[i] = array[j];
                        array[j] = temp;
                    }
                }
            }
            Console.WriteLine("after the select sort, the array as below:");
            for (int i = 0; i < array.Length; i++)
            {
                Console.Write(array[i] + " ");
            }
        }

        /// <summary>
        /// insert sort
        /// </summary>
        /// <param name="array"></param>

        static void Isort(int[] array)
        {
            int temp;
            for (int i = 1; i < array.Length; i++)
            {
                temp = array[i];
                int j = i;
                while (j > 0 && array[j - 1] > temp)
                {
                    array[j] = array[j - 1];
                    j--;
                }
                array[j] = temp;

            }
            Console.WriteLine("after the Insert sort,the array as below:");

            for (int i = 0; i < array.Length; i++)
            {
                Console.Write(array[i] + " ");
            }
        }

        static void QuickSort(int[] array,int left,int right)
        {
            //左边索引小于右边，则还未排序完成
            if (left < right)
            {
                //取中间的元素作为比较基准，小于他的往左边移，大于他的往右边移
                int middle = array[(left + right) / 2];
                int i = left - 1;
                int j = right + 1;
                while (true)
                {
                    while (array[++i] < middle && i < right) ;
                    while (array[--j] > middle && j > 0) ;
                    if (i >= j)
                        break;
                    //Swap(numbers, i, j);
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
                QuickSort(array, left, i - 1);
                QuickSort(array, j + 1, right);
            }



        }

        static void Main(string[] args)
        {
            int[] array = new int[10];
            List<int> list=new List<int>();
            Random rd=new Random();

            for(int i=0;i<10;i++)
            {
                int next=rd.Next(1,100);
                if (!list.Contains(next))
                {
                    list.Add(next);
                }
            }

            array = list.ToArray();

            Bsort(array);
            Console.WriteLine();
            SelectSort(array);
            Console.WriteLine();
            Isort(array);
            Console.WriteLine();
            QuickSort(array,0,array.Length-1);
            Console.WriteLine("after the quick sort,the array as below:");

            for (int m = 0; m < array.Length; m++)
            {
                Console.Write(array[m] + " ");
            }    

        }
    }    
}