常用的几种排序算

最近看了一下，算法中的排序，整理了一下，加了点自己的理解，欢迎指教，话不多说，开始撸代码
1、冒泡排序：
冒泡排序，我理解的是，取出第一个（最后一个），依次和相邻后面（前面）的比较，升序为例，比后面的大就交换，否则继续循环，在这只写出核心的代码

//1、冒泡排序：
public void pubbleSort(int[] list){
    int tmp =0;
    for(int i = 0; i < list.length-1; i++){
        for(int j = 0; j <list.length-1-i;j++){
            if(list[j] >list[j+1]){
                tmp =list[j];
                list[j] = list[j+1];
                list[j+1] =tmp;
            }
        }
    }
}

//2、选择排序
其实选择排序的基本原理是：我用大白话讲就是：第一次，找出最小的一个，与第一个位置的数交换，第二次，是在剩余的数中，找出最小的数，与第二个位置的数交换，继续到找完为止。个人觉得，他与冒泡排序的区别之一就是：冒泡排序是，只要找到比它小的就交换，而选择排序是找到比它小的，还要继续找，一直找到最小的。才交换，重要的、容易出错的地方我都已注释。

//2、选择排序
public void selectSort(int[] list){
    int index =0;
    for(int i=0; i < list.length; i++){
        int tmpSmall =list[i];
        int j =i+1;
        int index =i; //循环重要的条件，无此条件，待排序数组中部分有序是会有问题
        for(; j < list.length; j++){
            if(list[j] < tmpSmall){ //找到最小位置index；
                tmpSmall = list[j];
                index =j;
            }   
        }
        list[index] = list[i];  //非最小数待排序，放到最小数的位置
        list[i] =tmpSmall; //将最小数放到顺序位置，不能换成list[i] = list[j]
    }
}

//3、插入排序，其基本原理是：一个（n-1）个数的有序数列，将第n个数插入其中，使得这n个数还是有序。明白了吗？说白了就是：2、8 、10、19 、20,。现在有个数13.，你要想办法找到10之后19之前的位置，再将13插到其位置，插入之后依然是个有序数列。

//插入排序
public void insertSort(int[] list){
    for(int i =1; i < list.length; i++){
        int j =i-1;//第二个数为基数
        tmp = list[i];
        for(;j >=0 && tmp < list[j];j--){//基数位置往前找，比基数大的往后挪，给基数腾位置
            list[j+1] = list[j];
        }
        list[j+1] = tmp;//找到合适位置之后，还执行了j--所以j要加一
    }
}

//4、快速排序，快速排序和归并排序都用到了递归，有其相似之处。快速排序的原理：选择一个基准元素，一般就选择第一个或者是最后一个，加待排序的数列分成两部分，比基数大和比基数小。此时这个基数的位置就是最终排序的位置。然后用递归的方法，去排序化分的两个部分。

//快速排序
public void quickSort(int[] list,int start,int end){
    if(start < end){
        int mid =getMiddle(int[] list,start,end;
        quickSort(list,start,mid);
        quickSort(list,mid+1,end);
    }
}
public int getMiddle(int[],list,int low,int high ){
    int tmp = list[low];
    while(low< high ){
        while(low< high && list[low] <= tmp){
            low++;
        }
        list[high ] =list[low]
        while(low < high && list[high ] >= tmp){
            high--;
        }
        list[low] =list[high]
    }
    list[low] =tmp;
    return low;
}

//5、归并排序：
归并排序的原理：将两个或者两个以上的的有序表合并成一个新的有序表。

public void mergingSort(int[] list, int start, int end){
            if(start < end){
                int mid =start + ((end - start)>>1);
                mergingSort(list,start,mid);
                mergingSort(list,mid+1,end);
                merge(list,start,mid,end);
            }   
    }
public void merge(int[] list, int start, int center, int end) {
        int[] tmpArr =new int[end-start+1];
        int index =0;
        int tmp =start;
        int mid = center+1;
        while(start <= center && mid <= end){
            if(list[start] < list[mid]){
                tmpArr[index++] = list[start++];
            }else{
                tmpArr[index++] = list[mid++];
            }
        }
        while(mid <= end){
            tmpArr[index++] = list[mid++];
        }
        while(start <= center){
            tmpArr[index++] = list[start++];
        }
        for(int i=0; i < tmpArr.length;i++){
            list[tmp+i] = tmpArr[i];
        }

    }