Java实现快速排序、归并排序、堆排序和希尔排序

快速排序

算法思想

1.将数组的第一个元素取为target,定义两个指针i 和 j；
2.指针i ，从左向右找到第一个比target大的元素，指针j从右向左找到第一个比target小的元素，若i小于j,则交换i, j 指针指向的元素的值；
3.指针i继续从左向右搜索，指针j继续从右向左搜索，重复步骤2直到某一次停下来以后i>j，此时交换target与j指向元素的位置，这样即可保证target左边的元素都小于它，target右边的元素都大于它；
4.递归target左右两部分，直到只剩下1个元素。
平均、最好时间复杂度：O(nlgn) 最差时间复杂度：O(n^2)
空间复杂度：O(1) (也可以说需要的空间是O(n)，因为在递归调用时有栈的开销，最坏是O(n),平均是O(logn))

代码实现

public class QuickSort {
    public static void quickSort(int[] R, int low, int high){
        if(low >= high)
            return;
        int i = low+1;
        int j = high;
        while(i<j){
            while(R[i]<=R[low] && i<high)
                i++;
            while(R[j]>R[low] && j>low)
                j--;

            if(i<j){
                int temp = R[i];
                R[i] = R[j];
                R[j] = temp;
            }

        }
        int temp = R[j];
        R[j] = R[low];
        R[low] = temp;

        quickSort(R, low, j - 1);
        quickSort(R , j+1, high);
    }

    public static void main(String[] args) {

        int[] arr = new int[10000];
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = Math.abs(r.nextInt(1000));
        }

        quickSort(arr, 0, arr.length - 1);
        if (check(arr)) System.out.println("right");
        else System.out.println("wrong");

    }
    public static boolean check(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < arr[i - 1]) {
                System.out.println(arr[i - 1] + "   " + arr[i]);
                System.out.println("position is " + i);
                return false;
            }
        }
        return true;
    }
}

归并排序

算法思想

1.将原数组不断二分，直到叶节点只剩一个元素
2.将同属一个父节点的两个儿子合并成有序的数组，该父节点即变为有序数组
3.递归的划分并合并，即可得到最终有序的数组
平均、最好、最差时间复杂度：O(nlgn) 空间复杂度：O(n)

public class mergeSort {
    public static void merge(int[] R, int low1, int high1, int low2, int high2){
        int i = low1;
        int j = low2;
        int[] temp = new int[high1-low1+1+high2-low2+1];
        int index = 0;
        while(i<=high1 && j<=high2){
            if(R[i]<=R[j]){
                temp[index] = R[i];
                i ++;
            }
            else{
                temp[index] = R[j];
                j ++;
            }
            index ++;
        }

        if(i>high1){
            while(j<=high2){
                temp[index] = R[j];
                j ++;
                index ++;
            }
        }

        if(j>high2){
            while(i<=high1){
                temp[index] = R[i];
                i ++;
                index ++;
            }
        }

        int m = low1;
        for(int k=0;k<temp.length;k++,m++)
            R[m] = temp[k];
    }

    public static void MergeSort(int[] R, int low, int high){
        if(low >= high)
            return;
        int mid = (low+high)/2;
        MergeSort(R, low, mid);
        MergeSort(R, mid+1, high);
        merge(R, low, mid, mid+1, high);
    }

    public static void main(String[] args){
        int[] R = {5,7,3,19,4,9,17,15,12,31,23,30,5,8,1,17,16,5,3};
        MergeSort(R, 0, R.length-1);
        for(int i=0;i<R.length;i++)
            System.out.printf("%d ",R[i]);
    }
}

堆排序

public class HeapSort {

    public static void rebuildHeap(int[] A, int start, int end){
        int i = start;
        while(i<=end/2 -1) {
            if(A[i]>A[2*i+1] && 2*i+2<end && A[i]>A[2*i+2]|| A[i]>A[2*i+1] && 2*i+2>end )
                break;
            else{
                if(2*i+2<end) {
                    if (A[2*i + 1] >= A[2*i + 2]) {
                        swap(A, i, 2 * i + 1);
                        i = 2*i + 1;
                    }
                    else {
                        swap(A,i,2*i +2);
                        i = 2*i + 2;
                    }
                }
                else{
                    swap(A, i, 2 * i + 1);
                    i = 2*i + 1;
                }
            }
        }
    }

    public static void HeapSort(int[] A){
        int n = A.length;
        int start = n/2 - 1;
        for(int i=start;i>=0;i-- ){
            rebuildHeap(A, i, n-1);
        }
        for(int j=n-1;j>0;j--){
            swap(A, 0, j);
            rebuildHeap(A,0,j-1);
        }
    }
    public static void swap(int[] A,int a,int b){
        int temp = A[a];
        A[a] = A[b];
        A[b] = temp;
    }
    public static void main(String[] args){
        int[] A = new int[]{6,12,3,7,8,2,9,11,35,12,8,22};
        HeapSort(A);
        for(int i:A){
            System.out.println(i);
        }
    }
}

希尔排序

public class ShellSort {
    public static void shellSort(int[] A){
        for(int gap = A.length/2; gap > 0; gap/=2)
            for(int i=gap;i<A.length;i++){
                for(int j=i;j>=gap;j-=gap){
                    if(A[j]<A[j-gap]){
                        int temp = A[j];
                        A[j] = A[j-gap];
                        A[j-gap] = temp;
                    }
                    else break;
                }
            }
    }
    public static void main(String[] args){
        int[] A = new int[]{6,2,12,3,5,14,22,24,7};
        shellSort(A);
        for(int x:A)
            System.out.println(x);
    }
}