1.冒泡排序
我们直接看例子
假设有5个数：
5 4 3 2 1
我们要将它按从小到大的顺序排列，正常的思维我们会这么做
5 4 3 2 1
4 5 3 2 1
4 3 5 2 1
3 4 5 2 1
3 4 2 5 1
…
一次比较相邻的2个数，将小的换到前面
平均复杂度O(n^2)
class sort{
static void onesort(int a[]){
//要排序的数组
boolean flag=true;//判断交换是否还需要继续进行
while (flag) {
flag=false;
for (int i = 1; i < a.length-1;i++) {
if(a[i]>a[i+1]){
int x=a[i];
a[i]=a[i+1];
a[i+1]=x;
flag=true;//因为开始我们已经改成了false，如果没有可进行交换的flag就会是false 函数也就不会继续进行，这样会大大节省时间
}
}
}
}
}
2.选择排序
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
重复第二步，直到所有元素均排序完毕
还是这个例子：
5 4 3 2 1
1 4 3 2 5
1 2 3 4 5
平均复杂度O(n^2)
void swap(int *a,int *b) //交换函数
{
int temp = *a;
*a = *b;
*b = temp;
}
void selection_sort(int arr[], int len)
{
int i,j;
for (i = 0 ; i < len - 1 ; i++)
{
int min = i;
for (j = i + 1; j < len; j++) //遍历剩余未排序元素
if (arr[j] < arr[min]) //找到目前最小值
min = j; //记录最小值
swap(&arr[min], &arr[i]); //做交換
}
}
通常选择排序优于冒泡排序，冒泡排序在内循环交换，选择排序在外循环交换，效率差也就在这个交换次数上，毕竟O(n)<O(n^2)。如果数组完全有序，冒泡内循环的交换一次都不会执行，而选择排序每次还要和本身交换一次，此时冒泡效率高。但这种情况极少，所以丼从算法的角度看，选择优于冒泡
3.插入排序
在要排序的一组数中，假定前n-1个数已经排好序，现在将第n个数插到前面的有序数列中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。
例子如下：
5 4 3 2 1
从第二个数开始插入
5 4 未排序 ：3 2 1
因为4比5小 ，插入到5的前面
4 5 未排序 ：3 2 1
3 4 5 未排序 ：2 1
…
public static void insert_sort(int array[],int lenth){
int temp;
for(int i=0;i<lenth-1;i++){
for(int j=i+1;j>0;j--){
if(array[j] < array[j-1]){
temp = array[j-1];
array[j-1] = array[j];
array[j] = temp;
}else{
//不需要交换
break;
}
}
}
}
4.希尔排序
希尔排序可以认为是加强版的插入排序，它利用插入排序在数据量较小时和数据相对有序时的高效性，将一个数组在逻辑上按下标相隔距离进行分组，然后对每个组进行插入排序
public static void shell_sort(int array[],int lenth){
int temp = 0;
int incre = lenth;
while(true){
incre = incre/2;
for(int k = 0;k<incre;k++){
//根据增量分为若干子序列
for(int i=k+incre;i<lenth;i+=incre){
//当incre（也就是k）确定时，因为至少要2个元素才能进行插入排序，所以要插入的元素从k+incre开始枚举（第一个元素下标为k）
for(int j=i;j>k;j-=incre){
//依次用要插入的元素和前一个元素做比较
if(array[j]<array[j-incre]){
//比它小就交换，例如往 3 5 7 中插入4
/*3 5 4 7
3 4 5 7
*/
temp = array[j-incre];
array[j-incre] = array[j];
array[j] = temp;
}else{
break;//无法交换就退出
}
}
}
}
if(incre == 1){
break;//当incre为1时 整个数列分为了一组，进行插入排序一定是有序的故直接退出while
}
}
}
5.归并排序
归并排序的核心思想是分治，说的直白点就是将需要排序的数组分成很多小的数组进行排序，它和快速排序有异曲同工之妙
（图片来自知乎）
图中我们对未排序的数列进行分割，直到分割成一个一个的数据，再把这些数据两两归并到一起，使之有序，不停的归并，最后成为一个排好序的序列。
static void merge_sort_recursive(int[] arr, int[] result, int start, int end) {
if (start >= end)//正常情况开头是大于结尾的，除非已经分割成单个元素，则此时返回
return;
int len = end - start, mid = (len >> 1) + start;//len >> 1位运算，相当于除2
//找出当前数列中间的位置
int start1 = start, end1 = mid;//分割成2个数列
int start2 = mid + 1, end2 = end;
merge_sort_recursive(arr, result, start1, end1);//递归下去，对2个子序列排序
merge_sort_recursive(arr, result, start2, end2);
//经过上面的递归，start1~end1 ，start2~end2已经是有序的了
int k = start;
while (start1 <= end1 && start2 <= end2)
result[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];//从2个有序的里面选出小的
/*1 4 7 8 9
2 3 5
第一个选1
第二个选2
第三个选3
....
*/
while (start1 <= end1)//因为start1 <= end1 && start2 <= end2 中 有一个条件会先不满足，那么存在一个满足仍然是满足的，说明有元素没有赋值到 result数组，所以要加上
result[k++] = arr[start1++];
while (start2 <= end2)
result[k++] = arr[start2++];
for (k = start; k <= end; k++)
arr[k] = result[k];
}
public static void merge_sort(int[] arr) {
int len = arr.length;
int[] result = new int[len];
merge_sort_recursive(arr, result, 0, len - 1);
}
6.快速排序（图片来自啊哈算法）
应该是用的最多的吧，很多语言stl里的排序算法基本用的都是快速排序，上面我们说它和归并排序有异曲同工之妙，但也有差别；
区别：
进行分组的策略不同，合并的策略也不同。归并的分组策略：是假设待排序的元素存放在数组中，那么把数组前面的一半元素作为一组，后面一半作为另一组。而快速排序则是根据元素的值来分的，大于某个值的元素一组，小于某个值的元素一组。
快速排序在分组的时候已经根据元素的大小来分组了，而合并时，只需要把两个分组合并起来就可以了，归并排序则需要对两个有序的数组根据大小合并；
现在我们先看看快速排序怎么操作；
1.所先我们需要设定一个基数，作为分割点，一般我们选取数组最左边的数；
2.有了基数后，我们分别从左到右，从右到左遍历数组，记住是同时进行的
3.直到找到一个小于基数的数，和大于基数的数，然后我们对其进行交换；
（反复执行了很多次3操作）
4.如图所示，当2个兵兵碰头后，这个数组也就遍历完了
此时6（基数）比3大，我们就对齐进行交换
此时6左边都是小于6的数，右边都是大于6的数，然后将这2块分成2个数组递归下去，直到递归为一个大小为2的数组
然后我们合并这些数组就能得到有序的数组了；
blic class QuickSort {
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
int[] arr=new int[10];
for(int i=0;i<10;i++){
arr[i]=scan.nextInt();
}
QuickSort(arr, 0, arr.length-1);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static void QuickSort(int[] arr,int low,int high){
int i,j,temp,t;
if(low>high){
return;
}
i=low;
j=high;
//temp就是基准位
temp = arr[low];
while (i<j) {
//先看右边，依次往左递减
while (temp<=arr[j]&&i<j) {
j--;
}
//再看左边，依次往右递增
while (temp>=arr[i]&&i<j) {
i++;
}
//如果满足条件则交换
if (i<j) {
t = arr[j];
arr[j] = arr[i];
arr[i] = t;
}
}
//最后将基准为与i和j相等位置的数字交换
arr[low] = arr[i];
arr[i] = temp;
//递归调用左半数组
QuickSort(arr, low, j-1);
//递归调用右半数组
QuickSort(arr, j+1, high);
}
}