均爲從小到大排序
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;
}
}