冒泡排序，选择排序，插入排序，快速排序的比较及优化

第一次写博客，不对的地方欢迎指正

以下的测试时间只是在本人的电脑上直接运行的，只是简单的对比，并不是标准的时间，可能涉及到后台程序的影响

冒泡排序：时间复杂度O（n*n），可以从前向后，也可以从后向前进行排序，从后向前（自我感觉还是从后向前好，冒泡不就是向上冒），把最后一个和倒数第二个进行性比较，如果比第一个小就进行交换，这样小的数就换到了倒数第二个，倒数第二个再和倒数第三个进行比较，小再进行交换，直至最小的数被放到了第一个，之后再从后向前进行比较，直至换到第二个位置，以此类推，剩下一个数结束比较。（这个名字起的很形象）

以下是自己用10000个随机数进行测试，时间只记录排序时间！

package demo_sort;/** * 普通的冒泡排序：就像一个个泡向上漂，小的数字与前面的数字挨个进行比较，如果小于前面的就换位置 */import java.util.Random;public class MaoPao {public static void main(String[] args) {Random r=new Random();int array[]=new int[10000];for(int i=0;i<10000;i++){array[i]=r.nextInt(10000);}int lenth=array.length;long begin=System.currentTimeMillis();for(int i=0;i<lenth;i++){for(int j=lenth-1;j>i;j--){if(array[j-1]>array[j]){int temp;temp=array[j-1];array[j-1]=array[j];array[j]=temp;}}}long end=System.currentTimeMillis();System.out.println(end-begin+"ms");//for(int as:array){//System.out.println(as+" ");//}}}

通过多次运行得到的时间基本上维持在630ms左右

优化冒泡排序：设置一个标记，如果执行到某个位置标记重新赋值，下次执行判断标记是否符合条件符合执行循环交换（对于已经有排好的可以优化很多时间）
同样是10000个随机数

package demo_sort;/** * 优化的冒泡排序：如果给定的数组中已经有按照顺序排列的数字，不必要进行多次循环比较 * 不加优化：110多ms * 加优化：1ms */import java.util.Random;public class MaoPaoTest {public static void main(String[] args) {Random r=new Random();int array[]=new int[10000];for(int i=0;i<10000;i++){array[i]=i;}int lenth=array.length;int flag=1;long begin=System.currentTimeMillis();for(int i=0;i<lenth&&flag==1;i++){flag=0;for(int j=lenth-1;j>i;j--){if(array[j-1]>array[j]){int temp=array[j-1];array[j-1]=array[j];array[j]=temp;flag=1;}}}long end=System.currentTimeMillis();System.out.println(end-begin);}}

对于以上排好序的数组不加优化110ms，加了优化时间大幅价绍1ms

选择排序：选择排序顾名思义，选择出来进行排序，最开始先遍历一遍数组，选择出来最小的值放在数组第一个位置，之后再对第二个元素之后的元素进行遍历，选择出来最小的值放在这个子无序序列的第一位，也就是数组的第二个元素，这样前两个数就排完了，以此类推，复杂度O（n*n）

package demo_sort;/** * 选择排序算法 */import java.util.Random;public class SelectSort {public static void main(String[] args) {//int array[]=new int[]{9,6,3,2,8,7};Random r=new Random();int array[]=new int[10000];for(int i=0;i<10000;i++){array[i]=r.nextInt(10000);}int lenth=array.length;long begin=System.currentTimeMillis();for(int i=0;i<lenth;i++){for(int j=i+1;j<lenth;j++){if(array[i]>array[j]){int temp=array[i];array[i]=array[j];array[j]=temp;}}}long end=System.currentTimeMillis();System.out.println(end-begin+"ms");//for(int a:array){//System.out.println(a);//}}}

时间维持在700ms左右

插入排序：插入排序复杂度也是O（n*n），涉及到了元素的移动。先把数组中的第一个元素看成有序数列，查找与这个有序数列相邻元素，与有序数列中的每个元素进行比较，插入到合适的位置，直至有序数列中的元素和原数组元素相等排序完成。

package demo_sort;import java.util.Random;public class InsertSort2 {    public static void main(String[] args) {//        int array[]=new int[]{9,1,4,3,6};        int array[]=new int[10000];        Random r=new Random();        for(int i=0;i<10000;i++){            array[i]=r.nextInt(10000);        }        long begin=System.currentTimeMillis();        for(int i=1;i<array.length;i++){            for(int j=i;j>0;j--){                if(array[j-1]>array[j]){                    int temp=array[j];                    array[j]=array[j-1];                    array[j-1]=temp;                }            }        }        long end=System.currentTimeMillis();        System.out.println(end-begin+"ms");//        for(int a:array){//            System.out.println(a);//        }    }}

几次测试都会维持在200ms左右，相比以上的排序已经好不少，它是稳定排序，不改变相同元素原来的顺序。
优化的插入排序：

package demo_sort;import java.util.Random;public class InsertSort1 {public static void main(String[] args) {//int array[]=new int[]{9,5,8,1,4};int array[]=new int[10000];Random r=new Random();for(int i=0;i<10000;i++){array[i]=r.nextInt(10000);}long begin=System.currentTimeMillis();for(int i=1;i<array.length;i++){int temp=array[i];int j=i-1;while(j>=0&&array[j]>temp){array[j+1]=array[j];j--;}if(j!=i-1){array[j+1]=temp;}}long end=System.currentTimeMillis();System.out.println(end-begin+"ms");//for(int a:array){//System.out.println(a);//}}}

优化后10000个元素，排序用时80ms左右，和基本的插入排序相差一半，主要相差在循环上，减少不必要的循环

快速排序：，快速排序要求选择的枢轴值两边子序列长度最好一致，快速排序的时间消耗上主要在对元素的划分上，元素数量为k的数组，共需要比较k-1次。快速排序主要在于选择基准，如果选择的基准刚好是最小的或者最大的元素，那么这时候时间复杂度最大为O(n*n)，如果刚好选择的基准就是这个无序序列的中值，时间复杂度最小为O(nlgn)，总的关键字比较次数：O(nlgn)

快速排序对于数组元素重复率高的不适用。

快速排序为社么快，这里要提到一个分治思想，分而治之，虽然用到的是递归，虽然也有最坏情况下和冒泡，选择排序相等的时间复杂度，但是，分治思想是关键，把一个大问题分成两个小问题，分别同时处理，这两个小问题再向下分，最后问题也就水落石出了，分治思想避免了做无用功，选择一个基准，大于他的数在他的右面，小于他的数在他的左面，在进行比较的时候，左面的数只在左面进行比较就可以，没有必要再去右面比较，这样节省了时间

package demo_sort;import java.util.Random;public class QuickSort {public static void main(String[] args) {Random r=new Random();int a[]=new int[10000];for(int i=0;i<10000;i++){a[i]=r.nextInt(10000);}long begin=System.currentTimeMillis();sort(a,0,a.length-1);long end=System.currentTimeMillis();System.out.println(end-begin);//for (int i = 0; i < a.length; i++) {//System.out.println(a[i]);//}}public static void sort(int[] a, int low, int hight) {int i, j, index;if (low > hight) {return;}i = low;j = hight;index = a[i];while (i < j) {while (i < j && a[j] >= index) {j--;}if (i < j) {a[i++] = a[j];}while (i < j && a[i] < index) {i++;}if (i < j) {a[j--] = a[i];}}a[i] = index;sort(a, low, i - 1);sort(a, i + 1, hight);}}

几次运行的结果都会在80ms左右，这是在随机的条件下，其中有一次20ms，可见快速排序非常对得起他这个名字