排序算法总结（长期更新）

package sort;

/**冒泡排序的时间复杂度还是O(n^2)
* Created by zmy on 2016/4/3.
*/
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {1,3,5,23,4,63,23,56,43,22};
//这个循环是代表要进行5次挤最大的数
for (int i = 0; i < arr.length; i++){
//这个循环是代表要每次都把最大的挤到最后面
for (int j = 0; j < arr.length-i-1; j++){
if (arr[j] > arr[j+1]){
int a = arr[j];
arr[j] = arr[j+1];
arr[j+1] = a;
}
}
}
for (int x:arr){
System.out.println(x);
}
}
}

package sort;

/**
* 直接插入排序，算法时间复杂度是O(n^2)
* Created by zmy on 2016/4/4.
*/
public class InsertSort {
public static void main(String[] args) {
int[] arr = {1,2,3,21,2,12,4,21,11,4,12,45,123,23,4,14,1,2,4};

//遍历查出不是按顺序的，之后把这个数按顺序插进去
for (int i = 1; i < arr.length; i++){
if (arr[i] < arr[i-1]){
int temp = arr[i];
int k = i-1;
//这个步骤就是要把这个数插入到属于他的位置上了
for (int j = k; j > 0 && arr[j] > temp; j--){
arr[j+1] = arr[j];
//这不就是想获得j停止的时候的值
k --;
}
arr[k+1] = temp;
}
}
for (int x:arr){
System.out.print(x + " ");
}
}
}

package sort;

/**快速排序算法，这不是一种稳定的排序，使用了分治法的思想，时间复杂度是 O(n*log(n))
* Created by zmy on 2016/4/3.
*/
public class QuickSort {
//这个方法是选取基准数，之后将数组分成两个部分，i和j分别从两边出发，之后交换，我选择的基准数是数组中间的那个数
int partition(int[] arr, int left, int right){
int i = left,j = right;
int pivot = (left + right) / 2;
while(i <= j){
while (arr[i] < arr[pivot])
i++;
while (arr[j] > arr[pivot])
j--;
if (i <= j){
int tmp = arr[j];
arr[j] = arr[i];
arr[i] = tmp;
i++;
j--;
}
}
return i;
}
//递归分组 排序 在我看来 这是一种先整体 之后再局部的一种算法排序 先整体有序
int[] quicksort(int[] arr, int left, int right){
int index = partition(arr,left,right);
if (left < index -1 ){
quicksort(arr,left,index-1);
}
if (index < right){
quicksort(arr, index+1, right);
}

return arr;
}

public static void main(String[] args) {
int[] arr = {1,2,43,54,2,12,3,4,52,321,4,5,2,43,344,542,12,34};

QuickSort quickSort = new QuickSort();
int[] arr1 = quickSort.quicksort(arr,0,arr.length-1);
for (int i = 0; i < arr1.length; i++){
System.out.print(arr[i] + " ");
}

}
}