排序算法——七种排序算法汇总,详细

news2024/12/25 10:22:01

文章目录

  • 排序
    • 排序的概念及应用
    • 一、直接插入排序
      • 1. 简介
      • 2.动图展示
      • 3.过程
      • 4.代码
      • 5.总结
    • 二、希尔排序
      • 1.简介
      • 2.过程
      • 3.代码
      • 4.总结
    • 三、选择排序
      • 1.简介
      • 2.代码
      • 3.总结
    • 四、堆排序
      • 1.代码
      • 2.总结
    • 五、冒泡排序
      • 1.过程
      • 2.代码
      • 3.总结
    • 六、快速排序
      • 1.简介
      • 2.过程
      • 3.两种优化快速排序的思想
      • 4.代码-递归、非递归、优化
      • 5.总结
    • 七、归并排序
      • 1.简介
      • 2.过程
      • 3.代码
        • 1.递归
        • 2.非递归
    • 海量数据排序问题
      • 概念
      • 过程

排序

排序的概念及应用

排序∶所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。
稳定性:假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次序保持不变,即在原序列中,r[i]=r[j],且r[i]在r[j]之前,而在排序后的序列中,r[i]仍在r[j]之前,则称这种排序算法是稳定的;否则称为不稳定的。

一、直接插入排序

1. 简介

是一种最简单的排序方法,其基本操作是将一条记录插入到已排好的有序表中,从而得到一个新的、记录数量增1的有序表。

2.动图展示

在这里插入图片描述

3.过程

1. 将序列中第一个元素看为有序的,将数组划分为有序和无序部分

  • 下标i为待排序元素下标,从1开始。n个数需要n-1次遍历。
  • j=i-1
    在这里插入图片描述

2.每一次插入的比较都是从前一个数开始。即i下标位置待排序元素,与有序部分[0,j]下边处的末尾元素依次向前进行比较

  • 若array[i]>array[j]:则array[j+1]=array[i]
    在这里插入图片描述
    下标 i 处的元素插入到 j+1 位置。
    在这里插入图片描述

  • 若array[i]<array[j]:依次向前遍历有序区间,如果大于取出数,就将这个数后移,j-1
    在这里插入图片描述

  • array[j+1]=array[j] , 执行 j-- 操作
    在这里插入图片描述

  • 不断与 j 下标元素比较,出现小于2的数,找到了插入位置,所以跳出循环,2就可以插入数组了,下标是j+1
    在这里插入图片描述
    3.i++,待排序元素更新,同样执行第二步操作,直至无序部分所有元素遍历完成为止
    在这里插入图片描述
    ![在这里插入图片描述](https://img-blog.csdnimg.cn/2c811b7dc1ee4e18898da81fecd4c239.png
    在这里插入图片描述
    在这里插入图片描述
    如上依次操作即可。
    当待排序元素为2时,如下
    在这里插入图片描述
    经过排序插入后结果为如下:
    在这里插入图片描述
    可见经排序后,两个 2 的相对次序保持不变,说明直接插入排序是稳定的。

4.代码

public class TestSort {


    /**
     * 直接插入排序:
     * 时间复杂度:
     *            最坏情况下:O(N^2)  逆序的
     *            最好情况下:O(N)  有序     如果 以后 数据量不大  而且基本上 趋于有序【优化】
     * 空间复杂度:O(1)
     * 稳定性:稳定
     *
     * 一个本身就稳定的排序,一定也可以实现为不稳定的
     *
     * 但是本身就是不稳定的排序,你能把它变为稳定的排序吗?
     *
     * @param array
     */
    public static void insertSort(int[] array) {

        for (int i = 1; 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 {
                    //array[j+1] = tmp;
                    break;//
                }
            }
            array[j+1] = tmp;
        }
    }
    public static void main(String[] args) {

        int[] array = {1,5,2,7,9,6,5,7};

        System.out.println("排序前:"+Arrays.toString(array));

        insertSort(array);

        System.out.println("排序后:"+Arrays.toString(array));
    }
}

5.总结

时间复杂度:

  1. 最坏情况下:O(n^2)
  2. 最好情况下:O(n) 有序情况下

空间复杂度: O(1)
稳定性: 稳定

二、希尔排序

1.简介

希尔排序法:又称缩小增量法。希尔排序法的基本思想是:先选定一个整数gap,把待排序文件中所有记录分成几个组,所有距离为gap的记录分在同一组内,并对每一组内的记录进行排序。然后,取比上次数小的gap,重复上述分组和排序的工作。当到达=1时,所有记录在统一组内排好序。

2.过程

在这里插入图片描述

3.代码

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


public class TestSort {

    /**
     *
     *
     * @param array
     * @param gap
     */
    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 {
                    //array[j+1] = tmp;
                    break;//
                }
            }
            array[j+gap] = tmp;
        }
    }

    /**
     * 时间复杂度:
     *
     * 空间复杂度:
     * O(1)
     * 稳定性:
     * 不稳定
     * @param array
     */
    public static void shellSort(int[] array) {
        int gap = array.length;//10
        while (gap > 1) {
            gap /= 2;
            shell(array,gap);
        }
        shell(array,1);
    }


    public static void main(String[] args) {

        int[] array = {1,5,2,7,9,6,5,7};

        System.out.println("排序前:"+Arrays.toString(array));

        shellSort(array);

        System.out.println("排序后:"+Arrays.toString(array));
    }
}

4.总结

1.希尔排序是对直接插入排序的优化。
2.当gap > 1时都是预排序,目的是让数组更接近于有序。当gap ==1时,数组已经接近有序的了,这样就会很快。这样整体而言,可以达到优化的效果。我们实现后可以进行性能测试的对比。
3.希尔排序的时间复杂度不好计算,需要进行推导,推导出来平均时间复杂度: O(N^1.3)
O(N^2)
4. **空间复杂度:**O(1)
5. 稳定性: 不稳定

三、选择排序

1.简介

每一次 **从待排序的数据元素**中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。

2.代码

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


public class TestSort {

    /**
     * 选择排序:
     * 时间复杂度:O(N^2)
     * 空间复杂度:O(1)
     * 稳定性: 不稳定
     * @param array
     */
    public static void selectSort(int[] array) {
        for(int i=0;i<array.length;i++){
        	for(int j=i+1;j<array.length;j++){
        		if(array[j]<array[i]){
        			swwap(array,i,j);
        		}
        	}
        }
    }

	public static void selectSort2(int[] array) {
        for(int i=0;i<array.length;i++){
        	int minIndex=i;//记录 最小值的下标
        	int j=i+1;
        	for(;j<array.length;j++){
        		if(array[j]<array[minIndex]){
        			minIndex=j;
        		}
        	}
        	swwap(array,i,minIndex);
        }
    }

	public static void swap(int[] array,int i,int j){
		int temp=array[i];
		array[i]=array[j];
		array[j]=temp;
	}
    public static void main(String[] args) {

        int[] array = {1,5,2,7,9,6,5,7};

        System.out.println("排序前:"+Arrays.toString(array));

        selectSort(array);

        System.out.println("排序后:"+Arrays.toString(array));
    }
}

3.总结

时间复杂度: O(n^2)

空间复杂度: O(1)

稳定性: 不稳定

四、堆排序

1.代码

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


public class TestSort {

    /**
     * 堆排序
     * 时间复杂度:O(n*logn)  和数据有序无序无关
     * 空间复杂度:O(1)
     * 稳定性:不稳定
     * @param array
     */
    public static void heapSort(int[] array) {
        //1、大根堆 O(N)
        createHeap(array);
        //2、排序O(n*logn)
        int end = array.length-1;
        while (end > 0) {
            swap(array,0,end);
            shiftDown(array,0,end);//向下调整大根堆
            end--;
        }
    }

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

    private 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++;//他一定保存的是左右孩子的最大值的下标
            }
            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 temp=array[i];
		array[i]=array[j];
		array[j]=temp;
	}
	
    public static void main(String[] args) {

        int[] array = {1,5,2,7,9,6,5,7};

        System.out.println("排序前:"+Arrays.toString(array));

        heapSort(array);

        System.out.println("排序后:"+Arrays.toString(array));
    }
}

2.总结

时间复杂度: O(n*logn) 和数据有序无序无关

空间复杂度: O(1)

**稳定性:**不稳定

五、冒泡排序

1.过程

在这里插入图片描述

2.代码

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


public class TestSort {

    /**
     * 冒泡排序
     * 不针对优化:
     * 时间复杂度:O(N^2)
     * 空间复杂度:O(1)
     * 稳定性:稳定
     * @param array
     */
    public static void bubbleSort(int[] array) {

        for (int i = 0; i < array.length-1; i++) {
            //boolean flg = false;
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j] > array[j+1]) {
                    swap(array,j,j+1);
                    //flg = true;
                }
            }
            //if(flg == false) {
            //    break;
            //}
        }
    }
	
    public static void main(String[] args) {

        int[] array = {1,5,2,7,9,6,5,7};

        System.out.println("排序前:"+Arrays.toString(array));

        bubbleSort(array);

        System.out.println("排序后:"+Arrays.toString(array));
    }
}

3.总结

时间复杂度: O(N^2)

空间复杂度: O(1)

稳定性: 稳定

六、快速排序

1.简介

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法,其基本思想为∶任取待排序元素序列中的某元素作为基准值,按照该排序码将待排序集合分割成两子序列,左子序列中所有元素均小于基准值,右子序列中所有元素均大于基准值,然后左右子序列重复该过程,直到所有元素都排列在相应位置上为止。将区间按照基准值划分为左右两半部分的常见方式有:

  1. hoare版本
  2. 挖坑法
  3. 前后指针版本

分而治之的思想,它的排序过程是一个递归调用的过程。

2.过程

一趟排序过程如下,
在这里插入图片描述
从上图可以看到,完整的快速排序是建立在一趟快速排序之上的,它的具体步骤如下:

  1. 首先对待排序序列进行一趟快速排序;
  2. 一趟排序下来之后,基准元素(如30)的左边都是比它小的元素,右边都是比它大的元素;
  3. 再对基准元素左边的序列进行快速排序,对右边也进行快速排序;
  4. 重复步骤2、3,直到序列排序完成。

3.两种优化快速排序的思想

1.三数取中
面对完全有序的数组,快速排序每趟排序后,key的位置都在边缘,每层递归都只能固定一个数,时间复杂度变成了O(N^2)。

面对这种情况,我们可以在取key时动手脚。每次取key我们不再只取最左或最右的值。而是对比最左、最右、中间的三个元素,取三个元素中,值在另外两者中间的元素作为key。这样,就打乱了有序数组,大大加快了快速排序在面对这种情况时的速度。

2.小区间优化
快速排序对一个元素不多的数组排序,仍需要进行多次递归调用,我们知道递归是比较消耗资源的,所以为了避免在快速排序递归的最后几层大量调用函数,我们可以在数组元素较少时不再递归,而是采用直接插入排序替代,这样就能在不损失多少速度的情况下减少大量的递归次数,达到优化速度的目的。

4.代码-递归、非递归、优化

```java
import java.util.Arrays;
import java.util.Random;
import java.util.Stack;


public class TestSort {

    /**
     * 快速排序:
     *
     * 时间复杂度:
     *     最好情况:O(n*logn)  可以每次 尽量将待排序序列 均匀的分割
     *     最坏情况:O(n^2)  正序  逆序
     * 空间复杂度:
     *    最好情况:O(logn)
     *    最坏情况:O(N)
     *
     *  稳定性:不稳定的排序
     *
     * @param array
     */
    public static void quickSort1(int[] array) {
        quick(array,0,array.length-1);
    }

    /**
     * 三数取中法
     * @param array
     * @param left
     * @param right
     * @return 三个数中的 中间数字的下标
     */
    private static int threeMid(int[] array,int left,int right) {
        int mid = (left+right) >>> 1;
        if(array[left] < array[right]) {
            if(array[mid] < array[left]) {
                return left;
            }else if(array[mid] > array[right]) {
                return right;
            }else {
                return mid;
            }
        }else {
            // array[left] > array[right]
            if(array[mid] < array[right]) {
                return right;
            }else if(array[mid] > array[left]) {
                return left;
            }else {
                return mid;
            }
        }
    }


    /**
     *
     * @param array
     */
    private static void insertSort2(int[] array,int start,int end) {

        for (int i = start+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;
                    break;//
                }
            }
            array[j+1] = tmp;
        }
    }



    private static void quick(int[] array,int start,int end) {
        if(start >= end) {
            return;
        }
		
		//递归到小区间时,插入排序
        if(end-start+1 <= Constant.INSERT_SIZE) {
            //插入排序
            insertSort2(array, start, end);
            return;
        }

        //三数取中法-》start  end  mid 找到中间的数字
        //有序数据下的优化
        int index = threeMid(array,start,end);
        swap(array,index, start);

        int pivot = partition(array,start,end);
        quick(array,start,pivot-1);
        quick(array,pivot+1,end);
    }


    /**
     * 快速排序:非递归实现
     * @param array
     */
    public static void quickSort(int[] array) {
        Stack<Integer> stack = new Stack<>();

        int start = 0;
        int end = array.length-1;
        int pivot = partition(array,start,end);

        //左边有2个元素及以上
        if(pivot > start+1) {
            stack.push(start);
            stack.push(pivot-1);
        }
        //右边有2个元素及以上
        if(pivot < end-1) {
            stack.push(pivot+1);
            stack.push(end);
        }

        while (!stack.empty()) {
            end = stack.pop();
            start = stack.pop();
            pivot = partition(array,start,end);

            //左边有2个元素及以上
            if(pivot > start+1) {
                stack.push(start);
                stack.push(pivot-1);
            }
            //右边有2个元素及以上
            if(pivot < end-1) {
                stack.push(pivot+1);
                stack.push(end);
            }
        }
    }

    /**
     * 一次划分函数
     * @param array
     * @param left
     * @param right
     * @return
     */
    private static int partition(int[] array,int left,int right) {
        int tmp = array[left];
        while (left < right) {
            //1 2 3 4 5
            while (left < right && array[right] >= tmp) {
                right--;
            }
            //右边 找到小于tmp的数据
            array[left] = array[right];

            while (left < right && array[left] <= tmp) {
                left++;
            }
            //右边 找到小于tmp的数据
            array[right] = array[left];
        }
        array[left] = tmp;
        return left;
    }
	
    public static void main(String[] args) {

        int[] array = new int[10_0000];

        Random random = new Random();

        for (int i = 0; i < array.length; i++) {
            array[i] = i;
            //array[i] = random.nextInt(10_0000);
        }
        long startTime = System.currentTimeMillis();

        quickSort(array);

        long endTimes = System.currentTimeMillis();

        System.out.println(endTimes-startTime);
    }
}
public class Constant {

    public static final int INSERT_SIZE = 100;
}

5.总结

时间复杂度:

  • 最坏情况下:有序:O(n^2)
  • 最好情况下:O(n*logn) 尽量将待排序序列均匀分割

空间复杂度:

  • 最坏情况下:O(n)
  • 最好情况下:O(logn)

稳定性: 不稳定

七、归并排序

1.简介

归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide andConquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。归并排序核心步骤:

2.过程

在这里插入图片描述

3.代码

1.递归

/**
     * 归并排序
     * 时间复杂度:n*logn    不管有序还是无序
     * 空间复杂度:O(N)
     * 稳定性:稳定
     *
     * 冒泡   插入  归并
     * @param array
     */
    public static void mergeSort(int[] array) {
        mergeSortFunction(array,0,array.length-1);
    }

    private static void mergeSortFunction(int[] array,int low,int high) {
        if(low >= high) {
            return;
        }
        int mid = (low+high) >>> 1;
        mergeSortFunction(array,low,mid);
        mergeSortFunction(array,mid+1,high);
        merge(array,low,high,mid);
    }
    /**
     * 实现这个合并函数
     * @param array
     * @param low
     * @param high
     * @param mid
     */
    private static void merge(int[] array,int low,int high,int mid) {
        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++];
        }
        for (int i = 0; i < k; i++) {
            array[i+low] = tmp[i];
        }
    }

2.非递归

    /**
     * 归并排序 :非递归
     * @param array
     */
    public static void mergeSort2(int[] array) {
        int gap = 1;
        while (gap < array.length) {
            for (int i = 0; i < array.length; i += gap*2 ) {
                int low = i;
                int mid = low+gap-1;
                if(mid >= array.length) {
                    mid = array.length-1;
                }
                int high = mid+gap;
                if(high >= array.length) {
                    high = array.length-1;
                }
                merge(array,low,high,mid);
            }
            gap = gap*2;
        }
    }

海量数据排序问题

概念

内部排序:数据在内存上
外部排序:排序过程需要在磁盘等外部存储进行的排序
前提: 内存有1G,需要排序的数据有100G
因为内存中因为无法把所有数据全部放下,所以需要外部排序,而归并排序是最常用的外部排序

过程

  1. 先把文件切分成200份,每个512 M
  2. 分别对512M排序,因为内存已经可以放的下,所以任意排序方式都可以
  3. 200份文件进行2路归并,同时对200份有序文件做归并过程,最终结果就有序了

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/23371.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

【附源码】计算机毕业设计JAVA学生校内兼职管理平台

【附源码】计算机毕业设计JAVA学生校内兼职管理平台 目运行 环境项配置&#xff1a; Jdk1.8 Tomcat8.5 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; JAVA…

什么是 SSH 密钥? 生成、身份验证、密钥对信息等

SSH 密钥不仅可以提高安全性&#xff0c;还可以实现当今企业所需的大规模连接流程、单点登录 (SSO) 以及身份和访问管理的自动化。 什么是 SSH 密钥&#xff1f; SSH 密钥是安全外壳 (SSH) 协议中使用的安全访问凭证。 SSH 密钥使用基于公钥基础设施 (PKI) 技术&#xff08;数…

Android12窗口模糊(二)高斯模糊API源码解析

前言 在 Android 12 中&#xff0c;提供了一些用于实现窗口模糊处理效果&#xff08;例如背景模糊处理和模糊处理后方屏幕&#xff09;的公共 API。窗口模糊处理或跨窗口模糊处理用于模糊处理给定窗口后方的屏幕。 有两种窗口模糊处理方式&#xff0c;可用于实现不同的视觉效果…

不小心清空了回收站怎么恢复,回收站删除的东西可以恢复吗

不小心清空了回收站怎么恢复&#xff1f;回收站是操作系统提供的一个非常实用的功能&#xff0c;专门为用户保存从电脑硬盘删除的各种数据&#xff0c;因而很多时候我们都会用到回收站&#xff0c;它能够保存各种数据&#xff0c;我们也能够在里面恢复自己想要的数据&#xff0…

Flutter组件--AppBar相关属性

AppBar介绍 AppBar是基于Material Design设计风格的应用栏&#xff0c;一般使用在Scaffold内部&#xff0c;作为顶部导航栏。 为什么需要AppBar 1、因为导航栏里面一般由左侧功能键&#xff08;返回键、菜单键&#xff09;、标题、右侧功能键组成&#xff0c;而AppBar里面内置…

django的使用步骤详细

一、安装django pip install django 二、创建django项目 放django文件的的文件路径上输入cmd进入终端输入下面的命令 django-admin startproject 项目名称 三、app的创建 进入创建好的项目里面输入一下的命令 python manage.py startapp app名称 四、注册app 五、编写U…

计算机视觉:基于Numpy的图像处理技术(二):图像主成分分析(PCA)

计算机视觉&#xff1a;基于Numpy的图像处理技术&#xff08;二&#xff09;&#xff1a;图像主成分分析&#x1f3f3;️‍&#x1f308; 文章目录计算机视觉&#xff1a;基于Numpy的图像处理技术&#xff08;二&#xff09;&#xff1a;图像主成分分析:rainbow_flag:图像主成分…

企业数据泄漏事件频发,如何防止企业数据泄漏?

2022年即将接近尾声&#xff0c;这一年受疫情和国际经济形势影响&#xff0c;各行各业都不太好过&#xff0c;同样互联网领域发展不平衡、规则不健全、秩序不合理等问题日益凸显&#xff0c;虽然互联网的快速发展为企业数字化转型提供了支撑&#xff0c;但是互联网发展进程中“…

Android App开发动画特效之利用滚动器实现平滑翻页(附源码和演示 简单易懂)

需要图片集请点赞关注收藏后评论区留言~~~ 一、利用滚动器实现平滑翻页 在日常生活中&#xff0c;平移动画比较常见&#xff0c;有时也被称为位移动画&#xff0c;左右翻页和上下滚动其实都用到了平移动画&#xff0c;譬如平滑翻书的动画效果&#xff0c;就是位移动画的一种应…

BHQ-3 amine,1661064-89-6可在430nm至730nm范围内猝灭所有普通荧光团

英文名称&#xff1a;BHQ-3 amine CAS&#xff1a;1661064-89-6 外观&#xff1a;深紫色粉末 分子式&#xff1a;C32H36N7 分子量&#xff1a;518.69 储存条件&#xff1a;-20C&#xff0c;避光避湿 结构式&#xff1a; 凯新生物产品简介&#xff1a;干燥的寡核苷酸在环境…

如今传统企业如何做数字化转型?

如今传统企业如何做数字化转型&#xff1f; 传统企业的数字化转型&#xff0c;也分为大型企业和中小企业&#xff0c;二者的侧重是十分不同的&#xff01; 大型传统企业数字化转型的侧重点是—— 如何利用新一代信息技术&#xff0c;整合其现有技术和资源优势&#xff0c;在相…

MyBatis的缓存

目录 1.一级缓存 情况一 : 不同的SqlSession对应不同的一级缓存 情况二 : 同一个SqlSession但是查询条件不同 情况三 : 同一个SqlSession两次查询期间执行了任何一次增删改操作 情况四 : 同一个SqlSession两次查询期间手动清空了缓存 2.二级缓存 2.1二级缓存的相关配置 3.MyBa…

内网渗透神器CobaltStrike之会话管理(五)

CS之间派生会话 将CS1管理的会话派生至CS2中, 简单来说就是将CS1服务器的肉鸡送给CS2服务器 准备环境 主机描述Kali(192.168.47.134)CS TeamServer1Kali2(192.168.47.144)CS TeamServer2Windows7(192.168.47.133)CS客户端,攻击机Windows7(192.168.47.141)受害机操作步骤 首先…

详解:MySQL自增ID与UUID的优缺点及选择建议,MySQL有序uuid与自定义函数实现

文章目录1.自增ID的优缺点1.1 优点1.2 缺点1.3 不适合以自增ID主键作为主键的情况2.UUID作为主键2.1 介绍2.2 优点2.3 缺点3.有序UUID作为主键3.1 介绍3.2 演示使用3.2.1 前提知识3.2.1.1 数据类型 - binary3.2.1.2 函数 - hex()3.2.1.3 函数 - unhex()3.2.2 数据库层3.2.3 JAV…

web自动化测试(java+seleium)环境安装

目录0、应用1、linux安装1.1 安装chromium1.2 安装chromedriver1.3 安装xvfb2、java maven依赖selenium依赖3、入门案例0、应用 前一段时间&#xff0c;需要实现一个模拟页面操作的功能&#xff0c;去检测程序运行是否稳定&#xff0c;因此就用到了web自动化检测的功能。 1、实…

Centos8安装部署JumpServer堡垒机

1&#xff1a;安装支持在线安装和离线安装&#xff0c;我们选择在线安装一键部署。安装需要的环境要求。 OS/ArchArchitectureLinux KernelSoft Requirementlinux/amd64x86_64> 4.0wget curl tar gettext iptables pythonlinux/arm64aarch64> 4.0wget curl tar gettext …

highcharts 堆积图

参考 多坐标轴混合图 | JShare 使用 js资源 https://cdn.highcharts.com.cn/10.2.1/highcharts.js https://cdn.highcharts.com.cn/10.2.1/modules/exporting.js https://img.hcharts.cn/highcharts-plugins/highcharts-zh_CN.js 效果 js 引用 <script src"https…

【网页设计】期末大作业html+css(体育网站)--杜丹特篮球介绍8页 带报告

⛵ 源码获取 文末联系 ✈ Web前端开发技术 描述 网页设计题材&#xff0c;DIVCSS 布局制作,HTMLCSS网页设计期末课程大作业 | 校园篮球网页设计 | 足球体育运动 | 体育游泳运动 | 兵乓球 | 网球 | 等网站的设计与制作 | HTML期末大学生网页设计作业 HTML&#xff1a;结构 CSS&…

代码随想录刷题|LeetCode 343. 整数拆分 96.不同的二叉搜索树

目录 343. 整数拆分 思路 整数拆分 96.不同的二叉搜索树 思路 不同的二叉搜索树 343. 整数拆分 题目链接&#xff1a;力扣 思路 动态规划的题目虽然说是要先确定dp数组的含义&#xff0c;再确定递归公式&#xff0c;但是总感觉这两者是相辅相成的&#xff0c;是一起出来的&…

[附源码]java毕业设计校园飞毛腿系统

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis Maven Vue 等等组成&#xff0c;B/S模式 M…