快速排序

非递归

package 排序.快速排序;

import java.util.Arrays;
import java.util.Stack;

/**
 * @author: fs
 * @date: 2022/4/9 19:30
 * @Description:
 */
public class 快排非递归 {


    public static void quickSort(int[] array) {
        Stack<Integer> stack = new Stack<>();
        int left = 0;
        int right = array.length-1;
        int pivot = partition(array,left,right);
        if(pivot > left+1) {
            //左边有2个元素
            stack.push(left);
            stack.push(pivot-1);
        }
        if(pivot < right-1) {
            //右边有2个元素
            stack.push(pivot+1);
            stack.push(right);
        }

        while (!stack.isEmpty()) {
            right = stack.pop();
            left = stack.pop();

            pivot = partition(array,left,right);

            if(pivot > left+1) {
                //左边有2个元素
                stack.push(left);
                stack.push(pivot-1);
            }
            if(pivot < right-1) {
                //右边有2个元素
                stack.push(pivot+1);
                stack.push(right);
            }
        }
    }

    private static int partition(int[] array, int left, int right) {
        int i = left;
        int j = right;
        int pivot = array[left];
        while (i < j) {
            while (i < j && array[j] >= pivot) {
                j--;
            }
            while (i < j && array[i] <= pivot) {
                i++;
            }
            swap(array, i, j);
        }
        swap(array, i, left);
        return i;
    }

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

    public static void main(String[] args) {
        int[] arr={12,5,9,34,6,0,33,56,89,0,7,4,0,55,77};
        quickSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

递归：挖坑法

package 排序.快速排序;

import java.util.Arrays;

/**
 * @author: fs
 * @date: 2022/4/8 21:27
 * @Description:
 */
public class 快速排序挖坑法 {

    /**
     * 时间复杂度：
     * 最好【每次可以均匀的分割待排序序列】：O(N*logn)
     * 最坏：数据有序 或者逆序的情况 O(N^2)
     * 空间复杂度：
     * 最好：O(logn)
     * 最坏：O(n)   单分支的一棵树
     * 稳定性：不稳定的排序
     */

    public static void quickSort(int[] arr){
        quick(arr,0,arr.length-1);
    }

    public static void quick(int[] arr,int left,int right){
        if(left >= right) return;

        int pivot=partition(arr,left,right);//基准

        quick(arr,left,pivot-1);
        quick(arr,pivot+1,right);
    }

    public static int partition(int[] arr,int start,int end) {
        int tmp = arr[start];

        while (start < end) {
            while (start < end && arr[end] > tmp) {
                end--;
            }
            arr[start] = arr[end];

            while (start < end && arr[start] < tmp) {
                start++;
            }
            arr[end] = arr[start];
        }

        arr[start] = tmp;
        return start;
    }

    public static void main(String[] args) {
        int[] arr={12,5,18,10,4,2};
        quickSort(arr);
        System.out.println(Arrays.toString(arr));
    }

}

Hoare法

package 排序.快速排序;

import java.util.Arrays;

/**
 * @author: fs
 * @date: 2022/4/9 16:47
 * @Description:
 */
public class 快速排序Hoare法 {

    public static void quickSort(int[] arr){
        quick(arr,0,arr.length-1);
    }

    public static void quick(int[] arr,int left,int right){
        if(left >= right) return;

        int pivot=partition(arr,left,right);//基准

        quick(arr,left,pivot-1);
        quick(arr,pivot+1,right);
    }

    private static int partition(int[] array, int left, int right) {
        int i = left;
        int j = right;
        int pivot = array[left];
        while (i < j) {
            while (i < j && array[j] >= pivot) {
                j--;
            }
            while (i < j && array[i] <= pivot) {
                i++;
            }
            swap(array, i, j);
        }
        swap(array, i, left);
        return i;
    }

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

    public static void main(String[] args) {
        int[] arr={12,5,18,10,4,2};
        quickSort(arr);
        System.out.println(Arrays.toString(arr));
    }

}

找基准前使用三数取中和插入排序优化

package 排序.快速排序;

import java.util.Arrays;

/**
 * @author: fs
 * @date: 2022/4/9 19:02
 * @Description:
 */
public class 找基准前使用三数取中和插入排序优化 {

    public static void quickSort(int[] arr){
        quick(arr,0,arr.length-1);
    }

    public static void quick(int[] array,int left,int right) {
        if(left >= right) {
            return;
        }
        //0、如果区间内的数据，在排序的过程当中，小于某个范围了，可以使用直接插入排序  0  1  2 3
        if(right-left+1 <= 1400) {
            //使用直接插入排序
            insertSort2(array,left,right);
            return;
        }

        //1、找基准之前，我们找到中间大小的值-使用三数取中法
        int midValIndex = findMidValIndex(array,left,right);
        swap(array,midValIndex,left);

        int pivot = partition(array,left,right);//基准
        quick(array,left,pivot-1);
        quick(array,pivot+1,right);
    }

    public static int partition(int[] arr,int start,int end) {
        int tmp = arr[start];

        while (start < end) {
            while (start < end && arr[end] > tmp) {
                end--;
            }
            arr[start] = arr[end];

            while (start < end && arr[start] < tmp) {
                start++;
            }
            arr[end] = arr[start];
        }

        arr[start] = tmp;
        return start;
    }

    public static void insertSort2(int[] array,int start,int end) {
        for (int i = 1; i <= end; i++) {
            int tmp = array[i];
            int j = i-1;
            for (; j >= start ; j--) {
                if(array[j] > tmp) {
                    array[j+1] = array[j];
                }else {
                    //array[j+1] = tmp;  只要j回退的时候，遇到了 比tmp小的元素就结束这次的比较
                    break;
                }
            }
            //j回退到了 小于0 的地方
            array[j+1] = tmp;
        }
    }


    private static int findMidValIndex(int[] array, int start, int end) {
        int mid = start + ((end - start) >>> 1);
        if (array[start] < array[end]) {
            if (array[mid] < array[start]) {
                return start;
            } else if (array[mid] > array[end]) {
                return end;
            } else {
                return mid;
            }
        } else {
            if (array[mid] > array[start]) {
                return start;
            } else if (array[mid] < array[end]) {
                return end;
            } else {
                return mid;
            }
        }
    }

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

    public static void main(String[] args) {
        int[] arr={12,5,18,10,4,2};
        quickSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

归并排序

合并两个有序数组

package 排序.归并排序;

import java.util.Arrays;

/**
 * @author: fs
 * @date: 2022/4/9 19:56
 * @Description:
 */
public class 合并两个有序数组 {
    /**
     *
     * @param array1 有序的
     * @param array2 有序的
     * @return
     */
    public static int[] mergeArray(int[] array1,int[] array2) {
        //注意判断参数
        int[] tmp = new int[array1.length+array2.length];
        int k = 0;//
        int s1 = 0;
        int e1 = array1.length-1;

        int s2 = 0;
        int e2 = array2.length-1;

        while (s1 <= e1 && s2 <= e2) {
            if(array1[s1] <= array2[s2]) {
                tmp[k++] = array1[s1++];
                //k++;
                //s1++;
            }else {
                tmp[k++] = array2[s2++];
            }
        }

        while (s1 <= e1) {
            tmp[k++] = array1[s1++];
        }

        while (s2 <= e2) {
            tmp[k++] = array2[s2++];
        }
        return tmp;
    }

    public static void main(String[] args) {
        int[] arr1={1,3,5,7,9};
        int[] arr2={2,4,6,8,10};
        int[] tmp=mergeArray(arr1,arr2);
        System.out.println(Arrays.toString(tmp));
    }
}

递归法归并排序

package 排序.归并排序;

import java.util.Arrays;

/**
 * @author: fs
 * @date: 2022/4/9 20:20
 * @Description:
 */
public class 递归法归并排序 {
    /**
     * 归并排序：
     * 时间复杂度：O(N*logN)
     * 空间复杂度：O(N)
     * 稳定性：稳定的排序
     * 如果 array[s1] <= array[s2] 不取等号  那么就是不稳定的排序
     *
     * 学过的排序 只有3个是稳定的：
     * 冒泡   插入   归并
     */
    public static void mergeSort(int[] array) {
        mergeSortInternal(array,0,array.length-1);
    }

    private static void mergeSortInternal(int[] array,int low,int high) {
        if(low>=high) {
            return;
        }

        //int mid = (low+high) >>> 1;
        int mid = low + ((high-low) >>> 1);
        //左边
        mergeSortInternal(array,low,mid);
        //右边
        mergeSortInternal(array,mid+1,high);
        //合并
        merge(array,low,mid,high);
    }

    private static void merge(int[] array,int low,int mid,int high) {
        int[] tmp = new int[high-low+1];
        int k = 0;//

        int s1 = low;
        int e1 = mid;
        int s2 = mid+1;
        int e2 =  high;

        while (s1 <= e1 && s2 <= e2) {
            if(array[s1] <= array[s2]) {
                tmp[k++] = array[s1++];
            }else {
                tmp[k++] = array[s2++];
            }
        }

        while (s1 <= e1) {
            tmp[k++] = array[s1++];
        }

        while (s2 <= e2) {
            tmp[k++] = array[s2++];
        }
        //拷贝tmp数组的元素 放入原来的数组array当中
        for (int i = 0; i < k; i++) {
            array[i+low] = tmp[i];
        }
    }

    public static void main(String[] args) {
        int[] arr={12,5,9,34,6,0,33,56,89,0,7,4,0,55,77};
        mergeSort(arr);
        System.out.println(Arrays.toString(arr));
    }

}

非递归法归并排序

package 排序.归并排序;

/**
 * @author: fs
 * @date: 2022/4/9 21:15
 * @Description:
 */
public class 非递归法归并排序 {
    public static void mergeSort(int[] array) {
        int nums = 1;//每组的数据个数
        while (nums < array.length) {
            //数组每次都要进行遍历,确定要归并的区间
            for (int i = 0; i < array.length; i += nums*2) {
                int left = i;
                int mid = left+nums-1;
                //防止越界
                if(mid >= array.length) {
                    mid = array.length-1;
                }
                int right = mid+nums;
                //防止越界
                if(right >= array.length) {
                    right = array.length-1;
                }
                //小标确定之后，进行合并
                merge(array,left,mid,right);
            }
            nums *= 2;
        }
    }

    private static void merge(int[] array,int low,int mid,int high) {
        int[] tmp = new int[high-low+1];
        int k = 0;//

        int s1 = low;
        int e1 = mid;
        int s2 = mid+1;
        int e2 =  high;

        while (s1 <= e1 && s2 <= e2) {
            if(array[s1] <= array[s2]) {
                tmp[k++] = array[s1++];
            }else {
                tmp[k++] = array[s2++];
            }
        }

        while (s1 <= e1) {
            tmp[k++] = array[s1++];
        }

        while (s2 <= e2) {
            tmp[k++] = array[s2++];
        }
        //拷贝tmp数组的元素 放入原来的数组array当中
        for (int i = 0; i < k; i++) {
            array[i+low] = tmp[i];
        }
    }

}

堆排序

package 排序.堆排序;

/**
 * @author: fs
 * @date: 2022/4/9 14:10
 * @Description:
 */
public class 堆排序 {
    /*时间复杂度：O(N * log N)
    空间复杂度：O(1)
    稳定性：不稳定
    面试 写堆排序  就是 写的调整过程
    @param array*/

    public static void heapSort(int[] array) {
        //1、建堆  O(N)
        createHeap(array);
        int end = array.length-1;
        //2、交换然后调整 O(N * log N)
        while (end > 0) {
            swap(array,0,end);
            shiftDown(array,0,end);
            end--;
        }
    }

    public static void createHeap(int[] array) {
        for (int parent = (array.length-1-1)/2; parent >= 0 ; parent--) {
            shiftDown(array,parent,array.length);
        }
    }

    public static void shiftDown(int[] array,int parent,int len) {
        int child = 2*parent+1;//左孩子下标
        while (child < len) {
            if(child+1 < len && array[child] < array[child+1]) {
                child++;
            }
            //child下标 就是左右孩子最大值的下标
            if(array[child] > array[parent]) {
                swap(array,child,parent);
                parent = child;
                child = 2*parent+1;
            }else {
                break;
            }
        }
    }

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

插入排序

package 排序.插入排序;

import java.util.Arrays;

/**
 * @author: fs
 * @date: 2022/4/8 21:26
 * @Description:
 */
public class 插入排序 {
     /**
     * 时间复杂度：O(N^2)
     *      最好的情况是O(N): 对于直接插入排序来说，最好的情况就是数据有序的时候
     *      根据这个结论，推导出另一个结论：对于直接插入排序来说，数据越有序，越快。
     *
     * 空间复杂度：O(1)
     * 稳定性：稳定的
     *
     * 一个稳定的排序，可以实现为不稳定的排序
     * 但是一个本身就不稳定的排序，是不可以变成稳定的排序的
     *
     * @param array
     */
    public static void insertSort(int[] array){
        for(int i=0;i<array.length;i++){
            int tmp=array[i];//当前要被插入的数
            int j=i-1;
            for(;j>=0;j--){
                if(array[j]>tmp){//如果此式成立，则将较大的数往后移
                    array[j+1]=array[j];
                }else{
                    break;
                }
            }
//            回退到上一格，在此处插入要被插入的数
            array[j+1]=tmp;
        }
    }

    public static void main(String[] args) {
        int[] array={12,5,18,10,4,2};
        insertSort(array);
        System.out.println(Arrays.toString(array));
    }
}

希尔排序

package 排序.希尔排序;

import java.util.Arrays;

/**
 * @author: fs
 * @date: 2022/4/9 10:07
 * @Description:
 */
public class 希尔排序 {

    /*
     * 时间复杂度[和增量有关系的]：O(n^1.3 - n^1.5)
     * 空间复杂度：O(1)
     * 稳定性：不稳定的
     *   看在比较的过程当中  是否发生了跳跃式的交换 如果发生了跳跃式的交换  那么就是不稳定的排序
     * 基本上没有考过
     */

    public static void shell(int[] array,int gap) {
        for (int i = gap; i < array.length; i++ ) {
            int tmp = array[i];
            int j = i-gap;
            for (; j >= 0 ; j -= gap) {
                if(array[j] > tmp) {
                    array[j+gap] = array[j];
                }else {
                    break;
                }
            }
            array[j+gap] = tmp;
        }
    }

    public static void shellSort(int[] array) {
        int gap = array.length;
        while (gap > 1) {
            shell(array,gap);
            gap /= 2;
        }
        shell(array,1);//保证最后是1组
    }

    public static void main(String[] args){
        int[] arr={12,5,9,34,6,8,33,56,89,0,7,4,22,55,77};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

选择排序

package 排序.选择排序;

import java.util.Arrays;

/**
 * @author: fs
 * @date: 2022/4/9 10:40
 * @Description:
 */
public class 选择排序 {

    /**
     * 选择排序
     * 时间复杂度：O(N^2)
     *
     * 时间复杂度 != 代码的运行时间
     *
     * 其实 不是看你运行的时间 来说明的 时间只是一个衡量的某个标准
     * 空间复杂度：O(1)
     * 稳定性：不稳定的排序
     * @param
     */


    //方式1
    public static void selectSort1(int[] arr){
        for(int i=0;i<arr.length;i++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]<arr[i]){
                    int tmp=arr[j];
                    arr[j]=arr[i];
                    arr[i]=tmp;
                }
            }
        }
    }
    //方式2
    public static void selectSort2(int[] arr){
        for(int i=0;i<arr.length;i++){
            int minIndex=i;
            for(int j=i+1;j<arr.length;j++){
                //找到最小值下标
                if(arr[j]<arr[minIndex]){
                    minIndex=j;
                }
            }
            int tmp=arr[minIndex];
            arr[minIndex]=arr[i];
            arr[i]=tmp;
        }
    }

    public static void main(String[] args) {
        int[] arr1={2,5,4,9,3,2,1,4,6,7,12,78,65,0,0,1,9};
        int[] arr2={2,5,4,9,3,2,1,4,6,7,12,78,65,0,0,1,9};
        selectSort1(arr1);
        System.out.println(Arrays.toString(arr1));
        System.out.println("=======================");
        selectSort2(arr2);
        System.out.println(Arrays.toString(arr2));
    }
}

双向排序

package 排序.双向排序;

import java.util.Arrays;

/**
 * @author: fs
 * @date: 2022/4/9 13:24
 * @Description:
 */
public class 双向排序 {
    public static void selectSortOP(int[] array) {

        int low = 0;
        int high = array.length - 1;

        while (low < high) {
            int min=low;
            int max=low;
            for (int i = low ; i <= high; i++) {
                if (array[i] < array[min]) {
                    min = i;
                }
                if (array[i] > array[max]) {
                    max = i;
                }
            }
            swap(array, min, low);

            if(max==low)
                max=min;

            swap(array, max, high);
            low++;
            high--;
        }
    }

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

    public static void main(String[] args) {
       int[] array = { 9, 5, 2, 7, 3, 6, 8 };
        selectSortOP(array);
        System.out.println(Arrays.toString(array));
    }
}

计数排序

package 排序.计数排序;

/**
 * @author: fs
 * @date: 2022/4/10 8:50
 * @Description:
 */
public class 计数排序 {
    /**
     * 计数排序：
     * 时间复杂度：O(N)
     * 空间复杂度：O(M) M:代表 当前数据的范围900 - 999
     * 稳定性：当前代码是不稳定的，但是本质是稳定的
     *
     *
     * 一般适用于 有n个数，数据范围是0-n之间的
     * @param array
     */
    public static void countingSort(int[] array) {
        int maxVal = array[0];
        int minVal = array[0];
        for (int i = 1; i < array.length; i++) {
            if(array[i] < minVal) {
                minVal = array[i];
            }
            if(array[i] > maxVal) {
                maxVal = array[i];
            }
        }
        //说明，已经找到了最大值和最小值
        int[] count = new int[maxVal-minVal+1];//默认都是0
        //统计array数组当中，每个数据出现的次数
        for (int i = 0; i < array.length; i++) {
            int index = array[i];
            //为了空间的合理使用 这里需要index-minVal  防止923-900
            count[index-minVal]++;
        }
        //说明，在计数数组当中，已经把array数组当中，每个数据出现的次数已经统计好了
        //接下来，只需要，遍历计数数组，把数据写回array
        int indexArray = 0;
        for (int i = 0; i < count.length; i++) {
            while (count[i] > 0) {
                //这里一定要加minVal，因为不一定就是i出现了count[i]
                array[indexArray] = i+minVal;
                count[i]--;//拷贝一个之后，次数也就少一个
                indexArray++;//下标得向后移动
            }
        }
    }

}

冒泡排序

package 排序.冒泡排序;

import java.util.Arrays;

/**
 * @author: fs
 * @date: 2022/4/9 15:30
 * @Description:
 */
public class 冒泡排序 {
    /**
     * 冒泡排序
     * 时间复杂度：O(N^2)  这个代码 不管是好是坏  都是
     * 空间复杂度：O(1)
     * 稳定性：稳定的排序
     * @param
     */
    public static  void bubbleSort1(int[] arr){
        for(int i=0;i< arr.length-1;i++){
            for(int j=0;j< arr.length-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 bubbleSort2(int[] arr){
        for(int i=0;i< arr.length-1;i++){
            boolean flag=false;
            for(int j=0;j< arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int tmp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=tmp;
                    flag=true;
                }
            }
            if(flag==false)
                break;
        }
    }


    public static void main(String[] args) {
        int[] arr1={12,5,18,10,4,2};
        bubbleSort1(arr1);

        System.out.println(Arrays.toString(arr1));
        System.out.println("++++++++++++++++++++++");
        int[] arr2={12,5,18,10,4,2};
        bubbleSort2(arr2);

        System.out.println(Arrays.toString(arr2));
    }
}

随机生成数

package 排序;

import java.util.Arrays;
import java.util.Random;

import static 排序.归并排序.合并两个有序数组.mergeArray;
import static 排序.快速排序.快速排序挖坑法.quickSort;
import static 排序.计数排序.计数排序.countingSort;

/**
 * @author: fs
 * @date: 2022/4/10 9:17
 * @Description:
 */
public class 随机生成数 {

    /**
     * 有序的数据
     * @param capacity
     */
    public static void test1(int capacity) {
        int[] array = new int[capacity];
        for (int i = 0; i < array.length; i++) {
            array[i] = i;
        }
        long start = System.currentTimeMillis();
        //insertSort(array);
        //shellSort(array);
        //selectSort1(array);
        //heapSort(array);
        quickSort(array);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    /**
     * 无序的数据
     *
     * @param capacity
     */
    public static void test2(int capacity) {
        int[] array = new int[capacity];
        Random random = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(capacity);
        }
        long start = System.currentTimeMillis();
        //insertSort(array);
        //shellSort(array);
        //selectSort1(array);
        //heapSort(array);
        quickSort(array);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    //1M 2M   需要优化快拍
    public static void main2(String[] args) {
        test1(100_0000);
        //test2(1000_0000);
    }

    public static void main(String[] args) {
        //int[] array = {12,5,18,10,4,2};
        int[] array = {12, 5, 9, 34, 6, 0, 33, 56, 89, 0, 7, 4, 0, 55, 77};
        countingSort(array);
        System.out.println(Arrays.toString(array));
    }

    public static void main3(String[] args) {
        int[] array1 = {1, 3, 5, 7, 9};
        int[] array2 = {2, 4, 6, 8, 10};
        int[] ret = mergeArray(array1, array2);
        System.out.println(Arrays.toString(ret));
    }
}