单例模式

排序稳定性

意思就是说大小相同的两个值在排序之前和排序之后的先后顺序不变，这就是稳定的 ​

 

冒泡排序：

public class A01_BubbleDemo {
    public static void main(String[] args) {
//         冒泡排序：
//            核心思想：
//            1，相邻的元素两两比较，大的放右边，小的放左边。
//            2，第一轮比较完毕之后，最大值就已经确定，第二轮可以少循环一次，后面以此类推。
//            3，如果数组中有n个数据，总共我们只要执行n-1轮的代码就可以。
        //1.定义数组
        int[] arr = {2, 4, 5, 3, 1};
        //2.利用冒泡排序将数组中的数据变成 1 2 3 4 5
        //外循环：表示我要执行多少轮。 如果有n个数据，那么执行n - 1 轮
        for (int i = 0; i < arr.length - 1; i++) {
            //内循环：每一轮中我如何比较数据并找到当前的最大值
            //-1：为了防止索引越界
            //-i：提高效率，每一轮执行的次数应该比上一轮少一次。
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //i 依次表示数组中的每一个索引：0 1 2 3 4
                if(arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp; }
            }
        }
    }
}

冒泡排序是稳定排序

选择排序：

public class A02_SelectionDemo {
    public static void main(String[] args) {
//选择排序：
//                1，从0索引开始，跟后面的元素一一比较。
//                2，小的放前面，大的放后面。
//                3，第一次循环结束后，最小的数据已经确定。
//                4，第二次循环从1索引开始以此类推。
        //1.定义数组
        int[] arr = {2, 4, 5, 3, 1};
        //2.利用选择排序让数组变成 1 2 3 4 5
       /* //第一轮：
        //从0索引开始，跟后面的元素一一比较。
        for (int i = 0 + 1; i < arr.length; i++) {
            //拿着0索引跟后面的数据进行比较
            if(arr[0] > arr[i]){
                int temp = arr[0];
                arr[0] = arr[i];
                arr[i] = temp;
            }
        }*/
        //最终代码：
        //外循环：几轮
        //i:表示这一轮中，我拿着哪个索引上的数据跟后面的数据进行比较并交换
        for (int i = 0; i < arr.length -1; i++) {
            //内循环：每一轮我要干什么事情？
            //拿着i跟i后面的数据进行比较交换
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[i] > arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
  
}

插入排序：

public class A03_InsertDemo {
    public static void main(String[] args) {
//        插入排序：
//                将0索引的元素到N索引的元素看做是有序的，把N+1索引的元素到最后一个当成是无序的。
//                遍历无序的数据，将遍历到的元素插入有序序列中适当的位置，如遇到相同数据，插在后面。
//                N的范围：0~最大索引
        int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        //1.找到无序的哪一组数组是从哪个索引开始的。  2
        int startIndex = -1;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] > arr[i + 1]){
                startIndex = i + 1;
                break;
            }
        }
        //2.遍历从startIndex开始到最后一个元素，依次得到无序的哪一组数据中的每一个元素
        for (int i = startIndex; i < arr.length; i++) {
            //问题：如何把遍历到的数据，插入到前面有序的这一组当中
            //记录当前要插入数据的索引
            int j = i;
            while(j > 0 && arr[j] < arr[j - 1]){
                //交换位置
                int temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
                j--;
            }
        }
    }
}

快速排序

//1. 从数列中挑出一个元素，一般都是左边第一个数字，称为 "基准数";
//2. 创建两个指针，一个从前往后走，一个从后往前走。
//3. 先执行后面的指针，找出第一个比基准数小的数字
//4. 再执行前面的指针，找出第一个比基准数大的数字
//5. 交换两个指针指向的数字
//6. 直到两个指针相遇
//7. 将基准数跟指针指向位置的数字交换位置，称之为：基准数归位。
//8. 第一轮结束之后，基准数左边的数字都是比基准数小的，基准数右边的数字都是比基准数大的。
//9. 把基准数左边看做一个序列，把基准数右边看做一个序列，按照刚刚的规则递归排序
class Solution {
    Random r=new Random();
    public int[] sortArray(int[] nums) {
        int n=nums.length;
        help(nums,0,n-1);
        return nums;
    }
    public void help(int[]nums,int left,int right){
        if(left>=right){
            return ;
        }
        int index=left+r.nextIn t(right-left+1);
        int idx=nums[index];
        nums[index]=nums[left];
        int i=left;
        int j=right;
        while(j>i){
            while(j>i&&nums[j]>=idx){
                j--;
            }
            nums[i]=nums[j];
            while(j>i&&nums[i]<=idx){
                i++;
            }
            nums[j]=nums[i];
        }
        nums[i]=idx;
        help(nums,left,i-1);
        help(nums,i+1,right);
    }
}
``

复杂度分析：

时间复杂度：O(Nlog⁡N)，这里 N 是数组的长度；

空间复杂度：O(log⁡N)，这里占用的空间主要来自递归函数的栈空间。

快速排序是不稳定排序。

归并排序

归并排序算法的原理如下：

​ 1.把长度为n的输入序列分成两个长度为n/2的子序列；

​ 2.对这两个子序列分别采用归并排序；

​ 3.将两个排序好的子序列合并成一个最终的排序序列。

public static void main(String[] args) {
    int[] arr = new int[]{7,5,2,3,6,4};
    System.out.println("原始数组："+ Arrays.toString(arr));
    mergeSort(arr);
    System.out.println("排序后的数组："+ Arrays.toString(arr));
}

// 归并排序的入口方法
public static void mergeSort(int[] arr) {
    // 针对特殊情况，数组为空或只有一个元素时，无需排序
    if(arr == null || arr.length <= 1  ){
        return;
    }
    // 创建一个临时数组用于归并操作
    int[] temp = new int[arr.length];

    // 调用实际的排序方法，传入数组、左边界、右边界和临时数组
    sort(arr, 0, arr.length - 1, temp);
}

// 归并排序的核心排序方法(递归调用的方法)
public static void sort(int[] arr,int left,int right,int[] temp) {
    //递归终止的条件
    if(left < right){
        //计算中间位置分割的下标
        int mid = (right + left) / 2;
        // 递归对左半部分进行排序
        sort(arr, left, mid, temp);
        // 递归对右半部分进行排序
        sort(arr, mid+1, right, temp);
        //合并
        merge(arr,left,mid,right,temp);
    }

}


// 归并排序的核心归并方法
public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
    int i = left;
    int j = mid + 1;
    int k = left;

    // 比较左右两部分的元素，并将较小的元素放入临时数组
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }

    //如果右边元素先放完，则将左边剩余的元素逐个放入临时数组中
    while (i <= mid) {
        temp[k++] = arr[i++];
    }

    //如果左边元素先放完，则将右边剩余的元素逐个放入临时数组中
    while (j <= right) {
        temp[k++] = arr[j++];
    }

    // 将临时数组的结果复制回原数组
    for (int l = left; l <= right; l++) {
        arr[l] = temp[l];
    }
}