均为从小到大排序
1.冒泡排序
冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。
优化
因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较
原始代码
public static void Bubbling(int[] arr){
int temp=0;
for (int i=arr.length-1;i>0;i--){
for (int j=0;j<i;j++){
if (arr[j]>arr[j+1]){
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
优化
public static void Bubbling(int[] arr){
boolean flag=true;
int temp=0;
for (int i=arr.length-1;i>0;i--){
flag=true;
for (int j=0;j<i;j++){
if (arr[j]>arr[j+1]){
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
flag=false;
}
}
if (flag){
break;
}
}
}
2 选择排序
选择排序（select sorting）也是一种简单的排序方法。它的基本思想是：第一次从arr[0]~arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]~arr[n-1]中选取最小值，与arr[1]交换，第三次从arr[2]~arr[n-1]中选取最小值，与arr[2]交换，…，第i次从arr[i-1]~arr[n-1]中选取最小值，与arr[i-1]交换，…, 第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。
public static void Selective(int [] arr){
int index,temp;
for (int i=0;i<arr.length-1;i++){
index=i;
for(int j=i;j<=arr.length-1;j++){
if (arr[index]>arr[j]){
index=j;
}
}
if(index!=i) {
temp = arr[i];
arr[i] = arr[index];
arr[index] = temp;
}
}
}
3 插入排序
插入排序（Insertion Sorting）的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。
public static void insert(int[] arr){
for (int i=1;i<arr.length;i++){
int index=i;
int temp;
while (true){
if (arr[index]<arr[index-1]){
temp=arr[index];
arr[index]=arr[index-1];
arr[index-1]=temp;
index--;
if(index==0){
break;
}
}else {
break;
}
}
}
}
4 希尔排序(这个算法最优，也最难写，调了半天，老夫觉得很牛掰)
希尔排序法介绍
希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。
希尔排序法基本思想
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止
代码
public static void Shell2(int[] arr){
int step=arr.length/2;
int temp;
while (step>0){
for (int i=step;i<arr.length;i++){
int j=i;
temp=arr[j];
while (temp<arr[j-step]){
arr[j]=arr[j-step];
arr[j-step]=temp;
j-=step;
if (j-step<0){
break;
}
}
}
step/=2;
}
}
5 快速排序
public static void quickSort(int[] arr ,int left,int right){
int l=left;
int r=right;
int temp=arr[left];
while (l<r){
while (l<r&& arr[r]>=temp){
r--;
}
if (l<r){
arr[l]=arr[r];
l++;
}
while (l<r&&arr[l]<=temp){
l++;
}
if (l<r){
arr[r]=arr[l];
r--;
}
}
arr[l]=temp;
if(l-1>left){
quickSort(arr,left,l-1);
}
if(r+1<right){
quickSort(arr,r+1,right);
}
}
6 归并排序
归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。
public static void mergeSort(int arr[],int left,int right,int[] temp){
if(left<right){
int mid=(left+right)/2;
mergeSort(arr,left,mid,temp);
mergeSort(arr,mid+1,right,temp);
merge(arr,left,mid,right,temp);
}
}
public static void merge(int[] arr,int left,int mid ,int right,int[] temp ) {
int l = left;
int j = mid + 1;
int t = 0;
while (l <= mid && j <= right) {
if (arr[l] <= arr[j]) {
temp[t] = arr[l];
t++;
l++;
} else {
temp[t] = arr[j];
t++;
j++;
}
}
while (j <= right) {
temp[t] = arr[j];
t++;
j++;
}
while (l <= mid) {
temp[t] = arr[l];
t++;
l++;
}
t=0;
for (int i = left; i <= right; i++) {
arr[i] = temp[t];
t++;
}
}
}
7 基数排序（桶排序）
将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列
public static void redixSort(int[] arr){
//先求出最大数的位数
int max=arr[0];
for (int i=1;i<arr.length;i++){
if (max<arr[i]){
max=arr[i];
}
}
int length=(max+"").length();
int [][] bucket=new int[10][arr.length];
int[] bucketCounts=new int[10];
for (int i=0;i<length;i++){
for (int j=0;j<arr.length;j++){
int f=(int)Math.pow(10,i);
int c=arr[j]/f%10;
bucket[c][bucketCounts[c]]=arr[j];
bucketCounts[c]++;
}
//将桶中所有元素复制到arr
int index=0;
for (int k=0;k<bucketCounts.length;k++){
if(bucketCounts[k]!=0){
for (int t=0;t<bucketCounts[k];t++){
arr[index++]=bucket[k][t];
}
bucketCounts[k]=0;
}
}
}
}
8 堆排序 （本宝宝觉得这个最难）
堆排序的基本思想是：
1)将待排序序列构造成一个大顶堆
2)此时，整个序列的最大值就是堆顶的根节点。
3)将其与末尾元素进行交换，此时末尾就为最大值。
4)然后将剩余n-1个元素重新构造成一个堆（这个地方的部分建堆是效率的最大提升点，很多博客讲堆排序这里都是重新完整建堆，效率率极其低下，这个地方是精髓），这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。
可以看到在构建大顶堆的过程中，元素的个数逐渐减少，最后就得到一个有序序列了.
public static void heapSort(int [] arr){
int temp=0;
for (int i=arr.length-1;i>=0;i--){
adjust(arr,i,arr.length);
}
for (int j=arr.length-1;j>=0;j--){
temp=arr[j];
arr[j]=arr[0];
arr[0]=temp;
adjust(arr,0,j);
}
}
public static void adjust(int [] arr ,int i ,int size){
int temp=arr[i];
for (int k=2*i+1;k<size;k=2*k+1){
if(k+1<size&&arr[k]<arr[k+1]){
k++;
}
if(arr[k]>temp){
arr[i]=arr[k];
i=k;
}else{
break;
}
}
arr[i]=temp;
}
}