冒泡排序、选择排序、插入排序

冒泡排序：

冒泡排序（Bubble Sort） 最为简单的一种排序，通过重复走完数组的所有元素，通过打擂台的方式两个两个比较，直到没有数可以交换的时候结束这个数，再到下个数，直到整个数组排好顺序。因一个个浮出所以叫冒泡排序。双重循环时间 O(n^2)

 算法描述：

1. 比较相邻两个数据如果。第一个比第二个大，就交换两个数
2. 对每一个相邻的数做同样1的工作，这样从开始一队到结尾一队在最后的数就是最大的数。
3. 针对所有元素上面的操作，除了最后一个。
4. 重复1~3步骤，知道顺序完成。

缺点：

1. 冒泡排序是一种效率低下的排序方法，在数据规模很小时，可以采用。数据规模比较大时，最好用其它排序方法。
2. 下述例子总对冒泡做了优化，添加了flag作为标记，记录序列是否已经有序，减少循环次数。

        public static void BubbleSortBig(int[] arr)
        {
            bool isSort = false;
            for (int i = 0; i < arr.Length-1; i++)
            {
                isSort = false;
                for (int j = 0; j < arr.Length - 1 - i; j++)
                {
                    if (arr[j]>arr[j+1])
                    {
                        isSort = true;
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
                if (!isSort )
                {
                    break;
                }
            }

选择排序：

选择排序（Select Sort） 是直观的排序，通过确定一个 Key 最大或最小值，再从带排序的的数中找出最大或最小的交换到对应位置。再选择次之。双重循环时间复杂度为 O(n^2)。

排序描述：

1. 在一个长度为 N 的无序数组中，第一次遍历 n-1 个数找到最小的和第一个数交换。
2. 第二次从下一个数开始遍历 n-2 个数，找到最小的数和第二个数交换。
3. 重复以上操作直到第 n-1 次遍历最小的数和第 n-1 个数交换，排序完成。

优缺点：

         public static void selectSort(int[] arr)
        {
            for (int i = 0; i < arr.Length-1; i++)
            {
                //定义最小值的下标为i
                int max = i;
                //从i+1各元素开始与i进行比较，截止到最后一个元素
                for (int j = i+1; j < arr.Length; j++)
                {
                    //如果发现有比自己小的元素，把这个元素的下标赋值给自己
                    if (arr[max]>arr[j])
                    {
                        max = j;
                    }
                }
                //和其它所有元素对比完之后，如果最小值下标变化，那么就是有新的最小值产生，让新的最 
                  小值和定义的最小值交换位置
                if (max!=i)
                {
                    int temp =arr[i];
                    arr[i] = arr[max];
                    arr[max] = temp;
                }
            }
        }

插入排序：

插入排序算法是一种简单的排序算法，也称为直接插入排序算法。它是一种稳定的排序算法，对局部有序的数据具有较高的效率。

插入排序是一种简单直观的排序算法，工作原理为构建有序序列，对于未排序元素，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间，直到排序完成，如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。理解了插入排序的思想后，我们便能够得到它的时间复杂度。对于n个元素，一共需要进行n-1轮比较，而第k轮比较需要进行k次数组元素的两两比较，因此共需要进行的比较次数为：1 + 2 + ... + (n-1)，所以插入排序的时间复杂度同冒泡排序一样，也为O(n^2)。

排序描述：

1.  从第一个元素开始，该元素可认为已排序。
2. 取出下一个元素，在排序好的元素序列中从后往前扫描
3. 如果元素(已排序)大于新元素，将该元素移到下一位置
4. 重复3.直到找到已排序的元素小于或等于新元素的位置
5. 将新元素插入该位置后
6. 重复2-5直到排序完成

 

        //将数组从前开始往后挨个进行排序，每一次外循环排序过后数组前面都是有序排列，数组后面等待进                    
          入下一次外循环进行排列
        public static void InsertSort(int[] arr)
        {
            //从第二个元素开始进行比较
            for (int i = 1; i < arr.Length; i++)
            {
                //如果现在这个元素比上一个元素小，那么定义一个temp来存储这个元素；定义一个j等于上    
                  一个元素下标；
                if (arr[i]<arr[i-1])
                {
                    int temp = arr[i];
                    int j = i - 1;
                    //把从下标为0—j的值和temp进行比较，如果小于temp，那么就后移一位
                    for (; j >= 0 && temp < arr[j]; j--)
                    {
                        //后移
                        arr[j + 1] = arr[j];
                    }
                    //当temp大于arr[j]或j<0时
                    arr[j+1] = temp;
                }
            }
        }