【算法】Java排序算法（更新中）

【算法】Java排序算法（更新中）

1、冒泡排序

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

排序原理： 1. 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。 2. 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大 值。

冒泡排序的时间复杂度分析 冒泡排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以， 我们分析冒泡排序的时间复杂度，主要分析一下内层循环体的执行次数即可。 在最坏情况下，也就是假如要排序的元素为{6,5,4,3,2,1}逆序，那么： 元素比较的次数为： (N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)(N-1)/2=N^2/2-N/2; 元素交换的次数为： (N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)(N-1)/2=N^2/2-N/2; 总执行次数为： (N^2/2-N/2)+(N2/2-N/2)=N^2-N; 按照大O推导法则，保留函数中的最高阶项那么最终冒泡排序的时间复杂度为O(N^2 ）.

int[] ary=new int[]{9,5,6,4,8,5,2,7,2,6,1,2};
for (int i = 0; i < ary.length-1; i++) {
    for (int j = 0; j < ary.length-i-1; j++) {
        if (ary[j]>ary[j+1]){
            int temp=ary[j+1];
            ary[j+1]=ary[j];
            ary[j]=temp;
        }
    }
}
System.out.println(Arrays.toString(ary));

2、桶排序

桶排序从整体来看也是一个非比较排序，是计数排序的升级版，其主要是先把序列中的数据划分为一个个的范围，每个范围相当一个桶，将数据放入桶中，每个桶分别进行排序，然后取出拼接即可。计数排序不适用于序列中max-min范围较广或者序列中的数据不是整数的情况，但是桶排序没有这些限制，其主要步骤是将数据放入桶中，桶中的数据自己排序.

**桶排序的思想是：**将数据放入桶中，每个桶中的元素分别进行排序，其实就是一种用空间换时间的算法，还包含一种分治思想。

int[] ary=new int[]{9,5,6,4,8,5,2,7,2,6,1,2};
int max=0;
for (int i = 0; i < ary.length; i++) {
    if (ary[i]>max){
        max=ary[i];
    }
}
int[] arys=new int[max];
for (int i = 0; i < ary.length; i++) {
    arys[ary[i]-1]++;
}
for (int i = 0; i < arys.length; i++) {
    for (int j = 0; j < arys[i]; j++) {
        System.out.print((i+1)+"\t");
    }
}

3、快速排序

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。

快速排序的最坏运行情况是 O(n²)，比如说顺序数列的快排。但它的平摊期望时间是 O(nlogn)，且 O(nlogn) 记号中隐含的常数因子很小，比复杂度稳定等于 O(nlogn) 的归并排序要小很多。所以，对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序。

public static void main(String[] args) {
    int[] ary=new int[]{9,5,6,4,8,5,2,7,2,6,1,2};
    quickSort(ary,0,ary.length-1);
    System.out.println(Arrays.toString(ary));
}
public static void quickSort(int[] ary,int left,int right){
    if (left>right)
        return;
    int i=left;
    int j=right;
    int temp=ary[left];
    while(i!=j){
        while(ary[j]>=temp&&i<j)
            j--;
        while(ary[i]<=temp&&i<j)
            i++;
        if (i<j){
            int t=ary[i];
            ary[i]=ary[j];
            ary[j]=t;
        }
    }
    ary[left]=ary[i];
    ary[i]=temp;
    quickSort(ary,left,i-1);
    quickSort(ary,i+1,right);
}

4、选择排序

排序原理：
1.每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则假定其他某个索引出的值为最小值，最后可以找到最小值所在的索引
2.交换第一个索引处和最小值所在的索引处的值

 int[] ary = new int[]{9,8,7,6,5,4,3,2,1};
 for (int i = 0; i <ary.length-1; i++) {
       int k = i;
       for (int j = i + 1; j < ary.length; j++) {
           if (ary[k] >= ary[j]) {
               k = j;
           }
       }
       int temp = ary[i];
       ary[i] = ary[k];
       ary[k] = temp;
   }
   System.out.println(Arrays.toString(ary));

5、插入排序

排序原理：
1.把所有的元素分为两组，已经排序的和未排序的；
2.找到未排序的组中的第一个元素，向已经排序的组中进行插入；
3.倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待
插入元素放到这个位置，其他的元素向后移动一位；

int[] ary=new int[]{9,8,7,6,5,4,3,2,1};
for (int i = 1; i < ary.length; i++) {
    for (int j = i; j >0 ; j--) {
        if (ary[j]<ary[j-1]){
            int temp=ary[j];
            ary[j]=ary[j-1];
            ary[j-1]=temp;
        }else{
            break;
        }
    }
}
System.out.println(Arrays.toString(ary));

6、希尔排序

排序原理：

1.选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组；

2.对分好组的每一组数据完成插入排序；

3.减小增长量，最小减为1，重复第二步操作。

增长量h的确定：增长量h的值每一固定的规则，我们这里采用以下规则：

int h=1
while(h<5){
h=2h+1；//3,7
}
//循环结束后我们就可以确定h的最大值；
h的减小规则为：
h=h/2

int[] ary=new int[]{9,5,6,4,8,5,2,7,2,6,1,2};
int h=1;
while(h<ary.length/2){
    h=2*h+1;
}
while(h>=1) {
    for (int i = h; i < ary.length; i++) {
        for (int j = i; j >=h ; j-=h) {
            if (ary[j]<ary[j-h]){
                int temp=ary[j];
                ary[j]=ary[j-h];
                ary[j-h]=temp;
            }else{
                break;
            }
        }
    }
    h=h/2;
}
System.out.println(Arrays.toString(ary));

7. 堆排序

堆是一个完全二叉树的数据结构，堆排序运用了完全二叉树的优势实现了排序效果，这里先记录一下，后续再来完善c++代码实现

#include <iostream>

using namespace std;

const int N=100010;
int heap[N],n,m,cnt;

void down(int u){
    int t=u;
    if(t*2<=cnt&&heap[u]>heap[t*2])u=t*2;
    if(t*2+1<=cnt&&heap[u]>heap[t*2+1])u=t*2+1;
    if(t!=u){
        swap(heap[t],heap[u]);
        down(u);
    }
}

int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%d",&heap[i]);
    cnt=n;
    for(int i=n/2;i;i--)down(i);
    while(m--){
        printf("%d ",heap[1]);
        heap[1]=heap[cnt--];
        down(1);
    }
    return 0;
}