三大基本排序算法

三大基本排序算法

快排与快排切分

public class quickSort {

    //快速排序的核心思想 分治+递归
    //采用操作里面 比较核心的就是 使用一个临时变量pivot存储中间量，然后空出来每次强制替换的话 就可以少很多事情、
    //时间复杂度O(NlogN)-O(N^2)
    //空间复杂度O(1)

    public static void quickSort(int[] array, int L, int R){
        if (L >= R){
            return;
        }
        int left = L, right = R;
        int pivot = array[left]; //空出左指针 充当交换的中间变量
        while (left <right){     //每一层循环 对应的是一次交换 前后交换

            while (left <right && array[right]>=pivot ) right--;

            if (left <right) array[left] =array[right];

            while (left <right && array[left] <= pivot) left++;

            if (left <right) array[right] = array[left];

            if (left >= right) array[left] =pivot; //循环跳出的条件是 左右指针重叠 然后将之前pivot的值复制回来
        }
        quickSort(array,L,left-1);
        quickSort(array,right+1,R);
    }

    //快排变体:快排切分
    //使用方法 就是递归的时候加一步选择就可以了
    //时间复杂度O(N)-O(N^2) 不需要全部遍历 最优情况就是N+N/2+N/4+...+N/N = 2N
    //空间复杂度O(1)
    public static int[] getTopNumbers(int[] array , int k){
        if (k == 0){
            return new int[0];
        }else if (k >= array.length){
            return array;
        }
        quickSortK(array,0,array.length-1,k);
        int[] res =new int[k];
        for (int i = 0; i < k; i++) {
            res[i] = array[i];
        }
        return res;
    }


    public static void quickSortK(int[] array, int L, int R, int K){
        if (L >=R ){
            return;
        }
        int left = L, right = R;
        int pivot = array[left];
        while (left<right){
            while (left < right && array[right] >= pivot) right--;

            if(left <right ) array[left]= array[right];

            while (left < right && array[left] <= pivot) left++;

            if (left <right) array[right] = array[left];

            if (left >= right) array[left] =pivot;
        }
        if (K <left) quickSortK(array,L,left-1,K);
        else if ( K == left) return;
        else {
            quickSortK(array,L,left-1,K);
            quickSortK(array,right+1,R,K);
        }
    }


    public static void main(String[] args) {
        int[] array={10,2,34,43,155,6,7,90,3};
        quickSort(array,0,array.length-1);
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(getTopNumbers(array,3)));
    }

}

堆排序

//堆排序
//思想：维护一个完全二叉树，可以保证其根节点永远是最小或者最大的 然后依次减少相应的节点数，取根节点
//时间复杂度

public class heapSort {


    public static void swap(int[] tree, int i, int j ){
        int tmp = tree[i];
        tree[i]= tree[j];
        tree[j]= tmp;
    }

    //对二叉树中任意节点进行heapify操作
    public static void heapify(int[] tree, int i ,int n ){

        if(i>n) return;
        int left = 2*i +1;
        int rigth = 2*i +2;
        int max = i;
        if (left < n && tree[left] > tree[max]) max = left;
        if (rigth< n && tree[rigth] > tree[max]) max = rigth;
        if (max != i ) {
            swap(tree,max,i);
            heapify(tree,max,n);
        }
    }
    //构造堆
    public static void buildHeap(int[] tree,int n){
        int parent = (n-1)/2;
        for (int i = parent; i >= 0; i--) {
            heapify(tree,i,n);
        }
    }

    //堆排序
    public static void heapSort(int[] tree,int n){
         buildHeap(tree,n);
        for (int i = n-1 ; i >= 0 ; i--) {
            swap(tree, i,0);
            heapify(tree,0, i);
        }


    }

    public static void main(String[] args) {
        int[] array={10,2,34,43,155,6,7,90,3};
        heapSort(array,array.length);
        System.out.println(Arrays.toString(array));
    }



}

归并排序

public class mergoSort {
    //归并排序
    //思想：分治
    //时间复杂度：无论好坏都是O(NlogN)

    public static void mergo(int[] array, int left, int right){

        if( left >= right) return;

        //分
        int mid = (left+right)/2;
        mergo(array,left,mid);
        mergo(array,mid+1,right);
        //合
        mergosort(array,left,right,mid+1);

    }


    public static void mergosort(int[] array, int left, int right, int mid){
        int[] tmp = new int[array.length];
        int p1 = left, p2= mid;
        int tmp_p=left;
        //比较
        while (p1 <mid && p2 <=right){
            if (array[p1] < array[p2]){
                tmp[tmp_p++] = array[p1++];
            }else {
                tmp[tmp_p++] = array[p2++];
            }

        }
        //剩余的直接移动
        while (p1 <mid){
            tmp[tmp_p++] = array[p1++];
        }
        while (p2 <=right){
            tmp[tmp_p++] = array[p2++];
        }
        for (int i = left; i <=right ; i++) {
            array[i] =tmp[i];
        }

    }


    public static void main(String[] args) {
        int[] array={10,2,34,43,155,6,7,90,3};
        mergo(array,0,array.length-1);
        System.out.println(Arrays.toString(array));
    }

}