java实现七种排序 （插入排序， 希尔排序， 插入排序， 快速排序， 简单选择排序， 堆排序， 归并排序）

package java_study.sort;

import org.junit.Test;

import java.util.Random;

/**
 * Created by ethan on 2015/6/20.
 */
public class Sort7 {
    public int[] arr = init(10);

    public int[] init(int len){
        if (len==0) return null;
        int[] arr = new int[len];
        Random random = new Random();
        for (int i=0; i<len; i++){
           arr[i] =  random.nextInt(1000);
        }
        return arr;
    }

    // 插入排序
    public int[] sort_insert(int[] arr) {
        if (arr == null) return null;
        for (int i = 1; i < arr.length; i++) {
            int tmp = arr[i];
            int j = i - 1;
            for (; j >= 0 && tmp < arr[j]; j--) {
                arr[j + 1] = arr[j];
            }
            arr[j + 1] = tmp;
        }
        return arr;
    }

    // 希尔排序
    public int[] sort_shell(int[] arr) {
        if (arr==null) return null;
        int len = arr.length;
        for (int i=len/2; i>0; i/=2){
            for (int j=0; j<i; j++){
                for (int m=j; m<len; m+=i){
                    int tmp = arr[m];
                    int n=m-i;
                    for (; n>=j&&tmp<arr[n]; n-=i){
                        arr[n+i] = arr[n];
                    }
                    arr[n+i]=tmp;
                }
            }
        }

        return arr;
    }

    // 冒泡排序
    public int[] sort_bubble(int[] arr) {
        if (arr == null) return null;
        for (int i=0; i<arr.length-1; i++){
            for (int j=0; j<arr.length-i-1; j++){
                if (arr[j]>arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
        return arr;
    }

    // 快速排序
    public int[] sort_fast(int[] arr) {
        if (arr==null) return null;
        sort_fast_implement(arr, 0, arr.length-1);
        return arr;
    }
    public void sort_fast_implement(int[] arr, int start, int end){
        if (start < end){
            int index = partition(arr, start, end);
            if (start<index){
                sort_fast_implement(arr, start, index-1);
            }
            if (index<end){
                sort_fast_implement(arr, index+1, end);
            }
        }
    }
    public int partition(int[] arr, int start, int end){
        int tmp = arr[start];
        while (start<end){
            while (start<end&&tmp<arr[end]){
                end--;
            }
            arr[start] = arr[end];
            while (start<end&&tmp>arr[start]){
                start++;
            }
            arr[end]=arr[start];
        }
        arr[start]=tmp;
        return start;
    }
    // 选择排序
    public int[] sort_choose(int[] arr) {
        if (arr == null) return null;
        for (int i=1; i<arr.length; i++){
            int min_index = i-1;
            for (int j=i; j<arr.length; j++){
                if (arr[min_index]>arr[j]){
                    min_index=j;
                }
            }
            if (min_index!=i-1){
                int tmp = arr[min_index];
                arr[min_index] = arr[i-1];
                arr[i-1] = tmp;
            }
        }
        return arr;
    }

    // 堆排序 ==> 小根堆逆序， 大根堆顺序
    public int[] sort_heap(int[] arr) {
        if (arr==null) return null;
        build_heap(arr);
        for (int i=arr.length; i>0; i--){
            int tmp = arr[0];
            arr[0] = arr[i-1];
            arr[i-1] = tmp;
            heap_adjust(arr, 0, i-1);
        }
        return arr;
    }
    //建堆
    public void build_heap(int[] arr){
        if (arr==null) return;
        if (arr.length==1) return;
        int last = arr.length/2 - 1;
        for (int i=last; i>=0 ;i--){
            heap_adjust(arr, i, arr.length);
        }
    }
    //adjust
    public void heap_adjust(int[] arr, int index, int len){
        if (index<0) return;
        if (index>=len) return;
        int left = index*2+1;
        if (left>=len) return;
        int right = index*2+2;
        int max_index = left;
        if (right<len && arr[right]>arr[ max_index]){
             max_index = right;
        }
        if (arr[ max_index] > arr[index]){
            int tmp = arr[ max_index];
            arr[ max_index] = arr[index];
            arr[index] = tmp;
            heap_adjust(arr,  max_index, len);
        }
    }

    // 归并排序
    public int[] sort_merge(int[] arr) {
        int[] tmp = new int[arr.length];
        sort_merge_implement(arr, 0, arr.length-1, tmp);
        return arr;
    }
    //
    public void sort_merge_implement(int[] arr, int start, int end, int[] tmp){
        if (start<end){
            int mid = (start+end)/2;
            sort_merge_implement(arr, start, mid, tmp);
            sort_merge_implement(arr, mid+1, end, tmp);
            merge_two_sorted_array(arr, start, mid, end, tmp);
        }
    }
    // merge 两个有序的数组
    public void merge_two_sorted_array(int[] arr, int start, int mid, int end, int[] tmp){
        int start1 = start;
        int end1 = mid;
        int start2= mid+1;
        int end2 = end;
        int index = start;
        while(start1<=end1 && start2<=end2){
            if (arr[start1]<arr[start2]){
                tmp[index++] = arr[start1++];
            }else{
                tmp[index++] = arr[start2++];
            }
        }
        while(start1<=end1){
            tmp[index++] = arr[start1++];
        }
        while (start2<=end2){
            tmp[index++] = arr[start2++];
        }
        for (int i=start; i<=end; i++){
            arr[i] = tmp[i];
        }
    }

    // test
    @Test
    public void test_sort_insert() {
        System.out.println("insert sort...........");
        print_array(arr);
        print_array(sort_insert(arr));
    }

    @Test
    public void test_sort_shell() {
        System.out.println("shell sort...........");
        print_array(arr);
        print_array(sort_shell(arr));
    }

    @Test
    public void test_sort_bubble() {
        System.out.println("bubble sort...........");
        print_array(arr);
        print_array(sort_bubble(arr));
    }

    @Test
    public void test_sort_fast() {
        System.out.println("fast sort...........");
        print_array(arr);
        print_array(sort_fast(arr));
    }

    @Test
    public void test_sort_choose() {
        System.out.println("choose sort...........");
        print_array(arr);
        print_array(sort_choose(arr));
    }

    @Test
    public void test_sort_heap() {
        System.out.println("heap sort...........");
        print_array(arr);
        print_array(sort_heap(arr));
    }

    @Test
    public void test_sort_merge() {
        System.out.println("merge sort...........");
        print_array(arr);
        print_array(sort_merge(arr));
    }

    public void print_array(int[] arr) {
        if (arr == null) return;
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}