学习笔记之算法（一）常用排序

总结一下自己学到几种常见的排序算法以及对这些算法的一些个人的理解。

一.桶排序

     打一个比方：有一个要排序的数组 A，我们找来k个桶B（k要大于A里面元素的最大的值），每个桶上面有各自的编号，B0~Bk。我们根据A里面各个元素的值，给对应的桶内放小球。比如A=｛5，2,  3，3｝，5出现了一次，就给B5桶内放一个小球，2出现了一次给B2放一个球，3出现了两次给B3放两个球。放好后我们只需从B0开始，检查每个桶里面的球就可以得到排序好的数组了。比如我们从B0看起，没有球，所以跳过，B1没有球，跳过，B2有一个球，那就输出2，B3有两个球，输出3，3，B5有一个球，输出5，所以得到｛2，3，3,5｝就是排序好的数组。

     代码实现：

    //桶排序
        public static void BookSort(int[] array)
        {
            int[] books = new int[GetMax(array)+1];//按照数组元素最大值申请相应大小的数据
            for (int i = 0; i < array.Length; i++)
            {
                books[array[i]]++;
            }
            int k=0;
           
            for (int i = 0; i < books.Length; i++)
            {
                if (books[i] > 0)
                {
                    for (int j = 0; j < books[i]; j++)
                    {
                        array[k] = i;
                        k++;
                    }
                }
            }
        }

注意：桶的大小至少要比待排序数组里面最大元素大1，这里我另外编写了一个GetMax（）方法用来获取最大值。

优点：速度快而且结构简单清晰，时间复杂度低，只有O（n）。缺点是有时候要申请较大的空间，比如要排序｛2,1,10000｝，就得申请一个大小为10001的桶数组来排序，这明显太浪费。所以桶排序一般用在数组的元素都比较小情况下。

二.插入排序

   打一个比方：有一些扑克牌，点数为5,3,4,4,6，要对这些牌进行排序。这里我们把5看作第0张，3看作第一张，跟数组的索引一样从0开始，我们先抽出第1张牌，也就是3，然后往3的左边开始找，找一个小于等于3的数，如果找到了就把3插入到这个数的后面，如果找不到说明3是最小的，那就把3放到最左边，所以我们得到3,5,4,4,6，接着我们抽出第2张牌，按照刚才的方法我们得到3,4,5,4，6，接着再依次抽出第3张，第4张分别进行相同的操作，最后我们得到的牌就是有序的了，为3,4,4,5,6

代码实现

  public static void InsertSort(int[] array)
        {
         for (int i = 1; i < array.Length; i++)
            { 
                int j=i;
                int temp=array[j];//其实抽出指的是用局部遍历记录下这个数的值，并不是直接改变这个数的值
            while(j>0&&array[j-1]>temp)//遍历抽出的元素的左边的元素，找一个大于temp的元素，找不到就把当前遍历的元素向右移一位。
            {
            array[j]=array[j-1];
                j--;
            }//退出循环说明找到了或者是到了尽头，那此时的j肯定是我们要插入的索引了
                array[j]=temp;
            }
            
       }

优点：不用额外申请另外的空间，直接在原数组排序。缺点：时间复杂度比较高，为O（n*n）（其实跟其他的排序算法比起来也不算高）

三.选择排序

思路：选择排序的思路是遍历数组找一个最小的元素，然后把这个元素跟数组的第1个元素交换，然后遍历剩余的元素再找一个最小的元素跟第2个元素交换，不断重复直到没有剩余的元素了，那么这时得到的就是排序好的数组。

代码实现：

  //选择排序
        public static void Sort3(int[] array)
        {
            int length = array.Length;
            int pointer = 0;//pointer表示每次要遍历的开始点
            int minIndex=0;//minIndex用来记录每次找到的最小值的索引
            while (length > 0)
            {
                int min=array[pointer];
                minIndex = pointer;
                for (int i = pointer; i < pointer+length; i++)//注意每次遍历之后length就会减1
                {
                    if (min > array[i])
                    {
                        min = array[i];
                        minIndex = i;
                    }
                }
                int temp = array[minIndex];//交换最小值
                array[minIndex] = array[pointer];
                array[pointer] = temp;
                length--;
                pointer++;
            }
        }

优缺点跟插入排序一样。

四.快速排序

举例：要排序一个数组A比如｛5,1,7，9,2,6,4，3,8｝

1.我们先把数组的最左端作为一个基准数，创建两个指针left和right分别指向数组的最左端和最右端的元素。               

2.先让right从右向左开始找一个比基准数小的数（注意：这里必须让right先开始找，原因后面会说），当找到以后，再让left从左向右找一个比基准数大的数，找到后，就将这两个数互换。得到｛5,1,3，9,2,6,4,7,8｝

 3.重复执行步骤2，直到right和left指向同一个元素，这时，我们就把当前的数跟基准数互换。此时得到｛2,1,3，4,5,6,9,7,8｝

可以看到此时的数组并不是有序的，但可以发现在基准数5的左边都是比5小的数，在5右边都是比5大的数。

4.现在我们以基准数5为分界点，将数组分成两个数组｛2,1,3,4｝和｛6,9,7,8｝，对这两个数组进行步骤1,2,3的操作，可以得到｛1，2,3,4｝和｛6,9,7，8｝

此时｛1,2,3,4｝已经有序了，｛6,9,7,8｝还没有，那么再以基准数6为分界拆分成两个数组｛｝和｛9,7,8｝，空数组直接忽略，执行步骤1,2,3得到｛7,8,9｝此时A所有的子数组都是有序的了，那么很明显A也已经排好序了（为什么要让right先开始找，我们可以用｛6,9,7,8｝举例，此时基准数6的右边已经都是比6大的数了，这时如果是先让left先开始找的话，那么left会先找到9，然后right会找到left，此时会调换6跟9 变成了｛9,6,7,8｝）

思路:快速排序主要是利用了分治和递归的思想，分治就是把一个问题分解成多个相同性质的子问题，当所有的子问题都解决了，总问题也就解决了。 而不断得把问题拆分并求解就要用到函数的递归调用啦

代码实现：

        //快速排序
        public static void Sort4(int[] array,int left,int right)
        {
            if (right<left||right==left)
            {
                return;
            }
            int l = left + 1;
            int r=right;
       
            while ( r>l ) 
            {
                while (array[r] >= array[left] && r > l)//如果只判断>可能会因为前后元素相等陷入死循环
                {
                    r--;
                }
                while (array[l] <=array[left] && r > l)
                {
                    l++;
                }
                if (r > l)
                {
                    int temp = array[r];
                    array[r] = array[l];
                    array[l] = temp;
                }
            }
                if (array[left] > array[l])
                {
                    int temp = array[r];
                    array[r] = array[left];//与基准值交换
                    array[left] = temp;
                }
            Sort4(array, left, r - 1);
            Sort4(array,l,right);
        }