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

冒泡排序

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] + " ");
        }

    }
}