常见排序算法小结

常见排序算法时间和复杂度如下图

冒泡排序

冒泡排序核心代码对于数组a[n]

 for(int i=0;i<str.length-1;i++){
            for(int j=i+1;j<str.length;j++){
                if(str[i]>str[j]){
                    swap(str,i,j);
                }
            }
        }

改进：
即使当发现数组已经有序是跳出循环，使用方法就是在设置一个flag，发现第二层的for循环一次都没有进行交换就是表明数组已经是有序的。
时间复杂度o(n^2);

插入排序

插入排序有3种，直接插入排序，二分插入排序，希尔插入排序
（1）直接插入核心代码

public static void sort(int[] a) {
        int[] b=new int[a.length];
        b[0]=a[0];
        int j;
        for(int i=1;ifor(j=i-1;j>=0&&a[i]//a[i]为每次取出的数
                    b[j+1]=b[j];
            }
            b[j+1]=a[i];
        }
    }

时间复杂度O(n^2).

(2)希尔排序
所谓希尔排序就是利用了直接插入排序，不过是把数据长度截成多个部分，gap就是所谓步长，我们知道，当插入排序的数据是有序时，最快，二随着gap缩小，序列也就渐渐有序，当gap=1是相当于直接插入排序

核心代码

    public static void shellSort(int a[]) {
        int gap=a.length/2;
        while(gap>0){
            for(int i=gap;iint temp=a[i];
                int j=0;
                for(j=i-gap;j>=0&&temp2;  
        }
    }

快速排序

快排的话常见的方式就是用递归，然后还有优化就是可以与插入排序结合的使用，另外三像切分快排主要用于重复元素很多的那种情况-》见我另外一篇博客快排及常见的两种优化方法

堆排序

利用的二叉树这个数据结构，并用到优先队列，优先队列,

先构建一个这样的二叉树，即是父节点比大于子节点，然后再对这个有序完全二叉树进行排序，这里用到一个方法，叫下沉，即sink

private void sink(int[] str,int k,int length) {
        while(2*kint j=2*k;//让j等于左子类
            if (less(str,2*k, 2*k+1)) j++;//比较子类的大小，让j等于较大的那个，并和其父亲比较，如果父亲比较小则交换他们，否则跳出循环
            if (!less(str,k, j)) break;
            swap(str,k, j);
            k=j;
        }
    }

堆排序核心主要这个方法进行构建堆和将堆排序。
先构建一个有序堆

 public void heapSort(int[] a){
        int length = a.length;
        for(int k=length/2;k>=1;k--){
            sink(a,k,length);//构建一个有序堆，让父节点大于两个子节点
        }

        while(length>1){
            swap(a,1,length--);//交换根节点和数组尾部，然后再用下层求出当前
            sink(a,1,length);//然后再用下层求出当前最大值或最小值，循环直到有序
        }
    }

PS:以上比较都是以int为例，如果是非基本类型我们可以用Comparable来比较，让对象实现这个接口，比较用compare即可

参考：
希尔排序参考