一些排序算法

　　在读大学的时候，数据结构的书可谓啃了N遍，所有排序算法更是一边一边的看。也试过不看书，把算法自己重新写一边。但是到现在，几乎又忘了，所以趁现在找工作期间，重新拿起数据结构，看看里面的排序算法。

　　1.冒泡排序：其基本思想是，对一个含有N个元素的数组，循环进行N-1次遍历，每次遍历时，把遍历集合中最小的数调换到最前面（也可以把最大的数调换到最后面），就像小的泡泡会冒出水面一样理解。接着用C#语言重新写一下。

//两种写法
        public static void BubbleSort(int[] sourceArr)
        {
            int i = 0, j = 0, temp = 0;
            for (i = 0; i < sourceArr.Length - 1; i++)
            {
                for (j = i + 1; j < sourceArr.Length; j++)
                { 
                    if (sourceArr[i] > sourceArr[j]) //每次比较，把最小的数字调换至最前端
                    {
                        temp = sourceArr[i];
                        sourceArr[i] = sourceArr[j];
                        sourceArr[j] = temp;
                    }
                }
            }
        }
        public static void BubbleSort2(int[] sourceArr)
        {
            int i = 0, j = 0, temp = 0;
            bool falg = true;
            for (i = 0; i < sourceArr.Length - 1&&falg; i++)
            {
                falg = false;  
                for (j = sourceArr.Length - 1; j >i; j--)
                {
                    if (sourceArr[j-1] > sourceArr[j])//从后到前，两两比较，把较小的“冒”至最前。
                    {
                        falg = true;   // 如果自始至终都没有进入，则表明已按顺序排列
                        temp = sourceArr[j - 1];
                        sourceArr[j - 1] = sourceArr[j];
                        sourceArr[j] = temp;
                    }
                }
            }
        }

 　 2。快速排序：是一种二叉树结构的交换排序方法。其基本思想是：设数组a中存放了N个数据元素，low为数组的低端下标，high为数组的高端下标，从数组中任意取一个数作为标准，调整数组a中各元素的位置，使得排在标准元素前面的数均小于标准元素，排在标准元素后面的数均大于标准元素。这样一来，标准元素就就排在了它应在的位置，并且数字中元素以标准元素为中心，分为两组。然后依次对这两个子数组进行方法类同的递归快速排序。递归的出口条件是low>=high

public static void QuickSort(int []sourceArr, int low, int high)
        {
            int i = low, j = high;
            int temp = sourceArr[low];
            while (i<j)
            {
                while (i < j && temp <= sourceArr[j]) j--; //从后到前搜索比关键字更小的数，如果没找到，j前移。
                if (i < j)  //如果i<j说明找到一个比关键字小的数，将其调整到前面来
                { 
                    sourceArr[i]=sourceArr[j]; 
                    i++;    //将i前移一格
                }
                while (i < j && temp >= sourceArr[i]) i++;
                if (i < j)
                {
                    sourceArr[j] = sourceArr[i];
                    j--;
                }
            }
            sourceArr[i] = temp;
            if (low < i) QuickSort(sourceArr,low,i-1);   //对左端子集合进行递归
            if (high > i) QuickSort(sourceArr,j+1,high); //对右端子集合进行递归
        }

   3.直接插入排序：其基本思想是，顺序第把待排序的数据元素按其关键字值大小插入到已排序的数据元素子集合的适当位置。子集合的元素个数从只有一个元素开始逐次增加，当子集合的大小最终与集合大小相同时排序完毕。

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