各种排序算法

1、冒泡排序

  最早接触到得排序算法，也是最熟悉的，效率可能也是最低的。它是稳定的，时间复杂度为O(n*n),空间复杂度为O(1)。
算法思想：
  相邻数据比较，最大/小沉到最后。

核心代码：

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

2、直接插入算法

  插入排序也是稳定的，平均空间，时间复杂度都和冒泡一样。
算法思想：
  将待排序的数据插入已排好的序列中。

核心代码：

for(int i=1;i<a.length;i++)
    for(int j=i-1;j>=0&&a[j]>a[j+1];j--)
        swap(a[j],a[j+1]);

3、希尔排序

  这是一个不稳定的排序算法，平均时间复杂度为O(nlog2n),空间复杂度为O(1)
算法思想：
  将数据分为若干组，然后进行插入排序。

核心代码：

//将直接插入排序的1换成gap
for(int gap=n/2;gap>0;gap/=2)
    for(int i=gap;i<n;i++)
        for(int j=i-gap;j>=0&&a[j]>a[j+gap];j-=gap)
            swap(a[j],a[j+gap]);

4、直接选择排序

不稳定，O(n2)，O(1)
算法思想：
 从无序区选最小的数据放在有序区最后，感觉很像冒泡，把最小的数据冒到最上面，但是不同的是选择排序是用数组的下标来确定位置，不是一次次交换数据。

核心代码：

for(int i=0;i<n;i++){
    int min = i;
    for(j=i+1;j<n;j++)
        if(a[j]<a[min])
            min = j;
    swap(a[i],a[min]);
}

5、归并排序

    稳定，O(nlogn),O(n)
算法思想：
    将有序数列合并。先递归，再合并。速度比冒泡、插入快很多。

//递归
void merge(int[] a,int first,int last,ing[] t){
    if(first<last){
        int mid = (first+last)/2;
        merge(a,first,mid,t);
        merge(a,mid+1,last,t);
        merge_array(a,first,mid,last,t);
    }
}
//将两个有序数列合并
void merge_array(int[] a,int first,int mid,int last,int[] temp){
    int f = first,j = mid+1;
    int m = mid,l = last,k = 0;
    while(f<=m&&j<=l){
        if(a[f]<=a[j])
            temp[k++] = a[f++]
        else
            temp[k++] = a[j++]
    }
    while(f<=m)
        temp[k++] = temp[k++];
    while(j<=l)
        temp[k++] = temp[j++];
    for(f=0;f<k;f++)
        a[first+f] = temp[f];
}

6、快速排序

    不稳定，O(nlogn)，O(logn)
算法思想：
    取一个数，比它大的放右边，小的放左边。大佬说的挖坑填数+分治法。

void quick(int[] a,int left,int right){
    if(left<right){
        int l = left,r = right,temp = a[l];//将第一个数作为标兵
        while(l<r){
            while(l<r&&a[r]>=temp)
                r--;
            if(l<r)
                a[l++] = a[r];
            while(l<r&&a[l]<=temp)
                l++;
            if(l<r)
                a[r--] = a[l];
        }
        a[l] = temp;
        quick(a,l,l-1);
        quick(a,l+1,r);
    }
}

7、堆排序

我认为最难的排序，看了好久都没看懂，现在继续去看T_T