排序算法

希尔排序

public class ShellSort {

    public static void main(String[] args){
        int[] arr={8,9,1,7,2,3,5,4,6,0};

        for(int step = arr.length/2;step>0;step/=2){

            for(int i=step;i<arr.length;i++){
                int tmp = arr[i];
                int j=i;
                while(j-step>=0 && arr[j-step]>tmp ){
                    arr[j]=arr[j-step];
                    j=j-step;
                }
                arr[j]=tmp;
            }
            for(int i=0;i<arr.length;i++) {
                System.out.print(arr[i]+" ");
            }
            System.out.println();
        }
        for(int i=0;i<arr.length;i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}

堆排序

public class HeapSort {
    public static int[] heapify(int[] data,int father,int len){
        int left = father *2+1;
        int right = father *2+2;
        int largestIndex = father;
        //存在左子树
        if(left<len && data[left]>data[largestIndex]){
            largestIndex = left;
        }

        if(right<len && data[right]>data[largestIndex]){
            largestIndex = right;
        }

        if(largestIndex!=father){
            swap(data,father,largestIndex);
            heapify(data,largestIndex,len);
        }
        return data;
    }

    public static void maxHeapify(int[] data,int len){
        for(int i=(int)Math.floor(len/2);i>=0;i--){
            heapify(data,i,len);
        }


    }

    private static void swap(int[] data, int father, int largestIndex) {
        int tmp = data[father];
        data[father] = data[largestIndex];
        data[largestIndex] = tmp;
    }

    public static void main(String[] args){
        int[] data={1,6,7,2,3,4,5};
        for(int i=0;i<data.length;i++) {
            maxHeapify(data, data.length-i);
            swap(data,0,data.length-i-1);
            for(int j=0;j<data.length;j++) {
                System.out.print(data[j]+" ");
            }
            System.out.println();
        }
    }
}

归并排序

/**
 * 归并排序
 * 将两个有序的数列合并成一个大的有序的序列。通过递归，层层合并，即为归并。
 **/
public class MergeSort {

    public void merge(int[] arr,int start,int mid,int end){
        int[] tmp = new int[end-start+1];
        for(int i=start;i<=end;i++){
            tmp[i-start]=arr[i];
        }

        int i=start,j=mid+1;//i j指向两个数组开头部分

        for(int k=start;k<=end;k++){
            if(i>mid){
                arr[k] = tmp[j-start];
                j++;
            }else if(j>end){
                arr[k] = tmp[i-start];
                i++;
            }else if(tmp[i-start]<tmp[j-start]){
                arr[k] = tmp[i-start];
                i++;
            }else{
                arr[k] = tmp[j-start];
                j++;
            }
        }
    }

    public void merge_sort(int[] arr,int start,int end){
        if(start>=end)
            return;
        int mid =(start+end)/2;
        merge_sort(arr,start,mid);
        merge_sort(arr,mid+1,end);
        merge(arr,start,mid,end);
    }

    public static void main(String[] args){
        int[] arr={1,5,6,2,4,8,11,20,3};
        MergeSort mergeSort = new MergeSort();
        mergeSort.merge_sort(arr,0,arr.length-1);
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }


    }
}