7大排序算法-Java实现

package paixu;
import java.util.*;

public class Sort {

    public static void main(String[] args){
        int[] arr = {4,5,2,9,6,7,8,1,3};
        //int[] arr = new int[]{4,3,7,9,8,2,1,5,6};
        //bubbleSort(arr);
        //selectSort(arr);
        //insertSort2(arr);
        //quickSort(arr,0,arr.length-1);
        //mergeSort(arr,0,arr.length-1);
        //shellSort(arr);
        heapSort(arr);

        for(int i = 0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }       
    }

    //冒泡排序
    public static void bubbleSort(int[] arr) {
        int len = arr.length;   

        for(int i=0;i<len-1;i++){//一共n-1趟
            for(int j=len-1;j>i;j--){//两两交换，最后将每趟将最小的数排在最前
                if(arr[j]<arr[j-1]){
                    int tmp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = tmp;
                }
            }
        }

    }

    public static void bubbleSort2(int[] arr) {
        int len = arr.length;       

        for(int i=0;i<len-1;i++){
            for(int j=0;j<len-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }

    }

    //选择排序
    public static void selectSort(int[] arr) {

        int n = arr.length;

        for(int i=0;i<n-1;i++){//最后一个位置不用管，i位置与后面的最小的交换
            int tmp = arr[i];
            int flag = i;
            for(int j=i+1;j<n;j++){
                if(arr[j]<tmp){
                    tmp = arr[j];
                    flag = j;
                }
            }
            if(i!=flag){

                arr[flag] = arr[i];
                arr[i] = tmp;
            }

        }

    }

    //插入排序
    public static void insertSort(int[] arr) {
        int n = arr.length;
        for(int i=1;i<n;i++){//假设前面已经排好，i位置与前面比较，插入到合适的位置
            int tmp = arr[i];
            int j = i;
            while(j>0){
                if(tmp<arr[j-1]){
                    arr[j] = arr[j-1];
                    arr[j-1] = tmp;
                }else{
                    break;
                }
                j--;
            }           
        }
    }
    public static void insertSort2(int[] arr) {
        int n = arr.length;
        for(int i=1;i<n;i++){
            int tmp = arr[i];
            int j = i;
            while(j>0 && arr[j]<arr[j-1]){
                arr[j] = arr[j-1];
                arr[j-1] = tmp;
                j--;
            }
        }
    }

    //快速排序
    /**快速排序通过将一个数组划分成两个子数组，通过递归调用自身为每个子数组快速排序
     * 如何划分：设定关键字，将比关键字小的数据放一组，比关键字大的放另外一组
     * 设置数组最左端的数据为关键字
     * 
     */
    public static void quickSort(int[] arr, int begin, int end) {

        if(begin >= end){
            return;
        }
        int i = begin;
        int j = end;
        int index = arr[i];

        while(i < j){
            while(i<j && arr[j]>index){
                j--;
            }
            if(i<j){
                arr[i] = arr[j];
                i++;
            }
            while(i<j && arr[i]<index){
                i++;
            }
            if(i<j){
                arr[j] = arr[i];
                j--;
            }           
        }
        arr[i] = index;

        quickSort(arr,begin,i);
        quickSort(arr,i+1,end);

    }

    //归并排序
    /**分为两组，分别排好，再合并
     * 各自的组自己递归从而排好 
     * 
     */
    public static void mergeSort(int[] arr, int begin, int end) {
        if(begin==end){
            return;
        }
        int mid = (begin+end)/2;        
        mergeSort(arr,begin,mid);
        mergeSort(arr,mid+1,end);
        merge(arr,begin,mid+1,end);     
    }

    public static void merge(int[] arr, int begin, int midM, int end) {
        int i = 0;
        int beginM = begin;
        int mid = midM-1;
        int n = end-begin+1;
        int tmparr[] = new int[n];
        while(beginM<=mid && midM<=end){
            if(arr[beginM]<=arr[midM]){
                tmparr[i++] = arr[beginM++];
            }else{
                tmparr[i++] = arr[midM++];
            }
        }
        while(beginM<=mid){
            tmparr[i++] = arr[beginM++];
        }
        while(midM<=end){
            tmparr[i++] = arr[midM++];
        }
        for(int j=0;j<n;j++){
            arr[begin+j] = tmparr[j];
        }
    }

    //希尔排序（插入排序）
    public static void shellSort(int[] arr) {
        int n = arr.length;
        int h = 1;//h步长
        while(h<n/3){
            h = h*3+1;
        }
        while(h>0){
            for(int i=h;i<n;i++){
                int tmp = arr[i];
                int j = i;
                while(j>h-1 && arr[j]<arr[j-h]){
                    arr[j] = arr[j-h];
                    arr[j-h] = tmp;
                    j = j-h;
                }
            }

            h = (h-1)/3;
        }
    }

    //堆排序
    public static void heapSort(int[] arr) {
        int n = arr.length;
        int i = 0;
        //制造大顶堆
        for(i=n/2-1;i>=0;i--){//调整非叶节点
            adjustHeap(arr,i,n-1);
        }
        for(i=n-1;i>=0;i--){//栈顶与最后一个元素交换
            int tmp = arr[0];
            arr[0] = arr[i];
            arr[i] = tmp;
            adjustHeap(arr,0,i-1);//剩下的调整成大顶堆
        }
    }

    private static void adjustHeap(int[] arr, int pos, int len) {

        int child;
        int tmp = arr[pos];

        for(child=pos*2+1;child<=len;child=child*2+1){
            if(child<=len-1 && arr[child]<arr[child+1]){
                child++;
            }
            if(tmp>=arr[child]){
                break;
            }
            arr[pos] = arr[child];
            pos = child;
        }
        arr[pos] = tmp;

    }   

}