常用排序算法

    • 一、插入排序
      • 1、直接插入排序
      • 2、折半插入排序
      • 3、希尔排序
    • 二、交换排序
      • 1、冒泡排序
      • 2、快速排序
    • 三、选择排序
      • 1、简单选择排序
      • 2、堆排序
        • （1）调整堆
        • （2）创建堆
    • 四、归并排序
    • 五、基数排序
    • 六、各种排序方法的比较

将一组杂乱无章的数据按一定规律顺次排列起来（由小到大或由大到小) ，即将无序序列排成一个有序序列的运算。

排序方法的分类：

image-20230910165616894

一、插入排序

基本思想：

每步将一个待排序的对象，按其关键码大小，插入到前面已经排好序的一组对象的适当位置上，直到对象全部插入为止。

类似我们玩扑克牌，每次抓到一张牌就放到合适的位置上，即边插边排序。

image-20230910170617398

有序插入方法：

  • 在插 a[i] 前，数组a的前半段(a[0] ~ a[i-1]) 是有序段，后半段(a[i]~a[n-1])是停留于输入次序的“无序段
  • 插入ali]使a[0]~ali-1]有序，也就是要为a[i]找到有序位置i (0<=j<=i)将a[i]插入在a[i]的位置上

如图所示：

下标由0~4的为有序段，4 ~ 10 为无序段

image-20230910174910806

查找插入位置的方法：

image-20230910171250543

1、直接插入排序

如图所示，使用三个变量 i、j、x

i：指向无序段的元素

j ：指向有序段的元素

x：保存即将插入的元素

image-20230910172152571

插入的步骤：

1、使用x变量复制元素

2、x 与 a[j] 比较，若大于则直接插入在 j+1 的位置上，若小于将 j 指向的元素往后移，然后j 指针向前移动

【过程演示】

1、假设即将插入的元素为 7 ，使用 x 保存即将插入的元素 x = a[4]

2、将 x 与a[j] 比较， 即 a[3] > x ，将 j 指向的元素向后移，j 向前移动。

image-20230910172825598

3、继续将 x 与 a[j] 比较，a[j] 仍然小于 x，继续向后移动

image-20230910173014295

4、直到 a[j] < x 或者 j <= 0 停止移动，对 j+1 的位置赋值，a[j+1] = x

image-20230910173344538

7、移动完，继续比较下一个元素，即 i++， j = i - 1，不断重复执行以上步骤。

【代码实现】

时间复杂度：O( n2 )

    /*** 直接插入排序* */public static int[] sort(int[] arr) {// i 指向即将要插入的元素for (int i = 0; i < arr.length; i++) {// x 作为 i 指针指向的元素的备份int x = arr[i];// j 指向有序段的元素，配合int j = i - 1;// 若 j 指向的元素 大于 即将插入的元素，则将有序段的元素向后移for (; j >= 0 && arr[j] > x; j--) {// j指向的元素向后移动arr[j + 1] = arr[j];}// 插入的位置arr[j + 1] = x;}return arr;}

2、折半插入排序

可以使用折半查找方法在有序段中查找插入的位置。

image-20230910182142389

  • 计算mid值 。
  • 比较 mid 和 插入元素的值，a[mid] 和 a[i]
    • 若 a[mid] < a[i] , 在右半区查找 low = mid + 1
    • 若 a[mid] > a[i] , 在左半区查找 high= mid -1
  • 不断循环以上操作，直到 low 超过了 high ，则 high+1 的位置则是插入的位置
  • 找到插入位置之后，需要将 high + 1 后面的元素向后移动，腾出位置，插入元素 a[i]

代码实现

  • 折半查找减少了比较次数，但是没有减少移动次数

  • 平均性能优于直接插入排序

时间复杂度仍然为：O（n2）

public static int[] sort(int[] arr) {// i 指向即将要插入的元素for (int i = 0; i < arr.length; i++) {// x 作为 i 指针指向的元素的备份int x = arr[i];int low = 0;int high = i -1;while(low <= high) {int mid = (low + high ) /2;if (arr[mid] > x) {// 去左区间查找high = mid -1;}else {// 右区间查找low = mid + 1;}}// high+1为插入的位置，需要移动 high+1 后边的元素for (int j = i-1; j >= high + 1; j--) arr[j+1] = arr[j];// 插入的位置arr[high + 1] = x;}return arr;}

3、希尔排序

在我们之前的插入排序算法，都是一个个移动，一个个比较，这样就导致了效率较慢的问题，那么如果能增加移动的步幅，效率是不是就会提高了。这就是希尔排序的思想出发点。

基本思想

先将整个待排记录序列分割成若干个子序列，分别进行直接插入排序待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。

特点

  • 缩小增量
  • 多遍插入排序

【演示】

如何分割成若干个子序列，使待排序元素减少呢？

image-20230910214419195

我们可以设置一个间隔增量，假设设置为5，每相隔 5个元素为一组，如下图所示：

image-20230910214536470

这样，我们对每一组进行一次插入排序，保证组内有序，并且我们可以看到，当使用间隔增量时，每次移动的步幅是不是就很大了。提高了效率

image-20230910214701590

接下来，缩小增量，假设设置为3，每相隔3个元素为一组，如下图所示：

image-20230910214940324

然后对每一组进行插入排序

image-20230910215023283

最后，对整组元素进行插入排序，此时序列保证基本有序

image-20230910215112239

【思路】

  • 定义增量序列，Dk ： DM > DM-1 > … > D1 = 1
    • 刚才的例子中：D3 = 5、D2 = 3、D2 = 1
  • 对每个 Dk 进行 “Dk - 间隔” 插入排序

【代码实现】

希尔排序是一种不稳定的排序方法

    public static int[] shell(int[] arr) {// 设置增量,逐渐缩小，直到缩小为1for (int gap = arr.length / 2; gap >= 1; gap = gap / 2) {// 以gap为间隔，对整个序列进行分组。然后每一组进行一次插入排序for (int i = 0; i < arr.length; i += gap) {int j = i - gap;int x = arr[i];for (; j >= 0 && arr[j] > x; j--) {// 向后移动，只不过步幅不再是1，而是增量gaparr[j + gap] = arr[j];}// 找到插入的位置arr[j + gap] = x;}}return arr;}

二、交换排序

1、冒泡排序

基于简单的交换思想，每趟俩俩比较，将元素小的放前面。

【案例演示】

初始：21,25,49,25* , 16,8

image-20230911220216401

image-20230911220440650

image-20230911220514035

总结

  • 有n个元素时，需要 比较 n-1 趟
  • 第 m 趟，需要比较 n-m趟

代码实现：

时间复杂度：O(n2)

    // 冒泡排序public static int[] sort(int[] arr) {int length = arr.length -1;for (int i = 0; i < length ; i++) { // 趟数for (int j = 0; j < length - i; j++) { // 每一趟比较的次数// 如果前一个元素大于后一个元素，就交换if (arr[j] > arr[j + 1]) {// 交换int res = arr[j];arr[j] = arr[j + 1];arr[j + 1] = res;}}}return arr;}

优点：

每趟结束时，不仅能挤出一个最大值到后面位置，还能同时部分理顺其他元素。

优化

1、在比较交换的过程中，如果某一趟中没有发生交换，其实我们就没必要在比较后面的几趟了，因为它已经是有序了。

如下图所示，在第六趟中，就没有发生交换。那么第七趟就没必要在进行比较了。

image-20230911223051099

2、在交换的过程中，使用了额外变量临时保存交换的值，其实我们可以利用异或运算，无需使用额外空间，并且异或运行要比普通交换快得多。

                    int res = arr[i];arr[i] = arr[j];arr[j] = res;// 相同为0，任何数与0异或等于它本身// 相同为0，任何元素与0异或等于它本身arr[j] = arr[j] ^ arr[j+1];arr[j+1] = arr[j] ^ arr[j+1];arr[j] = arr[j] ^ arr[j+1];

优化后的代码：

  // 冒泡排序public static int[] sort(int[] arr) {int length = arr.length -1;for (int i = 0; i < length ; i++) { // 趟数boolean flag = false;for (int j = 0; j < length - i; j++) { // 每一趟比较的次数// 如果前一个元素大于后一个元素，就交换if (arr[j] > arr[j + 1]) {// 交换// int res = arr[j];// arr[j] = arr[j + 1];// arr[j + 1] = res;// 相同为0，任何元素与0异或等于它本身arr[j] = arr[j] ^ arr[j+1];arr[j+1] = arr[j] ^ arr[j+1];arr[j] = arr[j] ^ arr[j+1];flag = true;}}// 如果未发生交换，就无需比较后面的几趟了if (!flag) break;}return arr;}

2、快速排序

快速排序是冒泡法的一种改进，每一趟排序都将待排序的序列分成左右俩个部分，然后对俩个部分再次进行递归操作。

基本思想

  • 任取一个元素作为中心，称为pivot：中心点
  • 所有比它小的元素一律放在 pivot 的前面，比它大的元素放在 pivot 的后边
  • 形成左右俩个子表，对俩个子表重新调整 中心元素，然后分别对俩个子表在进行快速排序

【案例演示】

  1. 利用 low、high 俩个指针，扫描序列
  2. 不断移动high指针，当 high 指针遇到比 pivot 小的，停止移动
  3. 不断移动 low指针，当low指针遇到比pivot大的，停止移动
  4. low 和 high 停止移动后，则交换俩个元素的值
  5. 不断重复 2,3,4 步，直到 low 和 high 指针相遇时，说明扫描完一趟了，将pivot 和 low或者 right 交换
  6. 此时 pivot 左边比它小，右边比它大，分割成了俩部分，在进行递归，重复2,3,4,5 操作。

1、假设选取第一个元素为中心点 pivot = 49

image-20230911225836319

2、移动 high 指针，直到遇见比 49 小的，停止移动

image-20230911230219694

3、high 停止移动后，开始移动 low 指针直到遇见比 pivot 大的

image-20230911230327006

4、low 和 high 都停止后，交换low和high的元素

image-20230911231119729

5、重复操作第2、3、4步，移动 high、low，然后进行交换

image-20230911231312941

6、继续移动 high 指针，此时发现 low 和high 重合，交换 pivot 与重合位置的元素

image-20230911231449402

7、此时我们发现，pivot 左边比它小，右边比它大。完成了第一趟比较。

image-20230911231609992

8、此时分割成的俩部分，继续递归重复以上操作

image-20230911231815707

代码实现

  // 重载public static void sort(int[] arr) {sort(arr, 0, arr.length-1);}public static void sort(int[] arr, int low, int high) {if (low > high) return;// 使用额外的两个变量保存左右指针，方便操作// 真正移动的是 l和h指针int l = low;int h = high;// 第一个元素设置为中心元素int pivot = arr[low];while (l != h) {// 移动右指针，当遇到比pivot小的停止while (arr[h] >= pivot && l < h) h--;// 移动左指针，当遇到比pivot大的停止while (arr[l] <= pivot && l < h) l++;// 当左右指针都停止后，交换元素为止int temp = arr[l];arr[l] = arr[h];arr[h] = temp;}// 当左右指针相遇时，交换pivot和相遇的位置元素// 此时 low 并没有动，一直指向第一个元素，也就是pivotarr[low] = arr[l];arr[l] = pivot;// 递归操作sort(arr, low, l - 1);sort(arr, l + 1, high);}

总结

假设对 {95、85、79、74、68、50、46} 这样的有序序列进行划分 ，那么在第一次划分后，会得到其中一个子序列的长度为0，这时其实就退化成了冒泡排序

因此，快速排序不适于对原本有序或者基本有序的序列进行排序，这与插入排序时相反的。

三、选择排序

1、简单选择排序

基本思想

在待排序的数据中选出最小(大)的元素，放在最终的位置

基本操作

  • 首先通过n-1次关键字比较，从n个记录中找出关键字最小的记录，将它与第一个记录交换

  • 再通过 n-2次 比较，从剩余的 n-1个记录中找出关键字次小的记录，将它与第二个记录交换

  • 重复上述操作，共进行n-1趟排序后，排序结束

代码实现

    public static void sort(int[] arr) {for (int i = 0; i < arr.length; i++) {// 假设每一趟的第一个元素为最小值int k = i;for (int j = i + 1; j < arr.length; j++) {if (arr[j] < arr[k]) k =j;}if (k != i) {arr[i] = arr[k] ^ arr[i];arr[k] = arr[k] ^ arr[i];arr[i] = arr[k] ^ arr[i];}}}

2、堆排序

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：

  1. 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
  2. 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；

堆排序的平均时间复杂度为 Ο(nlogn)。

【案例演示】

将以下俩个序列转换成二叉树，判断是否是堆

{ 98、 77 、35 、62 、55 、14 、35 、48}

{14 、48、 35、 62、 55、 98、 35、 77]

转换之后，如下图所示：

左边的二叉树每个非叶子节点都大于它的孩子结点，因此它是大根堆

相反，右边的每个非叶子节点都小于它的孩子结点，因此它是小根堆

image-20230912222528931

从图中可以看出，对于大根堆，根节点就是最大的值，相反，小根堆的根节点就是最小的值。

因此我们只需要输出最大值（最小值），将剩下的元素继续调整一个堆，继续输出最大值（最小值）…如此反复，便能得到一个有序序列。

所以，堆排序最主要的俩个问题就是：

  • 如何将一个序列构建堆
  • 输出栈顶元素后，剩余元素如何调整成一个堆

以小根堆为例

（1）调整堆

  • 输出堆顶元素之后，以堆中最后一个元素替代之
  • 然后将根结点值与左、右子树的根结点值进行比较，并与其中小者进行交换
  • 如果是大根堆，则与其较大者进行交换
  • 重复上述操作，直至叶子结点，将得到新的堆，称这个从堆顶至叶子的调整过程为"筛选"

【演示】

1、初始情况

image-20230913173422305

2、输出根顶元素，并以最后一个元素 97 替换

image-20230913173615690

3、比较左右孩子结点，并与其较小者交换，直到成为叶子结点

： 38 < 27 , 将 97 与 27 交换

： 65 < 49 ，将 97 与 49 交换

image-20230913174022244

4、重复执行 2、3 步，不断输出根顶结点，然后调整堆

【代码实现】

  /*** @description 调整小根堆* @date 2023/9/13 18:12* @param arr 数组* @param i 需要开始调整结点的下标* @param length 数组的长度* @return void*/public static void adjustHeap(int[] arr, int i, int length) {// 先保存该结点int parent = arr[i];// i的左孩子结点： 2i+1// i的右孩子结点：2i+2for (int childIndex = 2 * i + 1; childIndex < length; childIndex = 2 * childIndex + 1) {// 判断左孩子与右孩子的大小，如果右孩子大，则将j指针指向右孩子if (childIndex+1 < length && arr[childIndex] < arr[childIndex+1]) {childIndex++;}// 判断根结点与左右孩子结点的大小if (parent < arr[childIndex]) {// 如果小于左右孩子结点，将左右孩子结点复制给父结点// 此时 arr[i]为较小左右孩子结点的值arr[i] = arr[childIndex];// 此时 i 指针指向较小的左右孩子结点i = childIndex;}else {break;}}// 将父结点的值赋值给较小的左右孩子结点，实现了交换arr[i] = parent;}

（2）创建堆

创建堆其实就是一个 反复 筛选 的过程

  • 单结点的二叉树是堆
  • 在完全二叉树中所有的叶子结点都是堆，无需调整，直接从最后一个非叶子结点开始即可。

代码实现

        for (int i = arr.length / 2 - 1; i >= 0; i--) {adjustHeap(arr, i, arr.length);}

整体代码

package ChapterEight;import java.util.Arrays;/**** Author: YZG* Date: 2023/9/13 18:12* Description:*/
public class HeepSortClass {public static void main(String[] args) {int[] arr = {1, 3, 2, 8, 1, 9};HeepSortClass.heepSort(arr);}/*** @description 调整小根堆* @date 2023/9/13 18:12* @param arr 数组* @param i 需要开始调整结点的下标* @param length 数组的长度* @return void*/public static void adjustHeep(int[] arr, int i, int length) {// 先保存该结点int parent = arr[i];// i的左孩子结点： 2i+1// i的右孩子结点：2i+2for (int childIndex = 2 * i + 1; childIndex < length; childIndex = 2 * childIndex + 1) {// 判断左孩子与右孩子的大小，如果右孩子大，则将j指针指向右孩子if (childIndex+1 < length && arr[childIndex] < arr[childIndex+1]) {childIndex++;}// 判断根结点与左右孩子结点的大小if (parent < arr[childIndex]) {// 如果小于左右孩子结点，将左右孩子结点复制给父结点// 此时 arr[i]为较小左右孩子结点的值arr[i] = arr[childIndex];// 此时 i 指针指向较小的左右孩子结点i = childIndex;}else {break;}}// 将父结点的值赋值给较小的左右孩子结点，实现了交换arr[i] = parent;}public static void heepSort(int[] arr) {//从最后一个非叶子节点开始构建小顶堆for (int i = arr.length / 2 - 1; i >= 0; i--) {adjustHeep(arr, i, arr.length);}//进行 arr.length - 1 趟排序for (int j = arr.length - 1; j > 0; j--) {//将首个元素与末尾元素进行交换int temp = arr[0];arr[0] = arr[j];arr[j] = temp;//交换完，继续调整，使其符合小顶堆adjustHeep(arr, 0, j);}}
}

四、归并排序

归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即*分而治之)。

分： 将整个序列拆分成最小的序列，也就是一个元素一个序列。

治：将每个序列合并成有序的序列，最终合成一个大的有序序列

如下图所示：

第一步：将整个无序序列拆分成不可再分的序列

第二步：将拆分的序列合并成有序的序列

这里写图片描述

在合并俩个序列时，我们可以利用一个额外的数组temp[] 和俩个指针 i、j：

  • i、j 分别指向俩个即将合并的序列中的元素
  • 比较俩个指针指向的元素，哪个小就加到 temp 中，并且移动对应的指针，直到某个指针指向某个序列的结尾
  • 将剩余的元素增加到 temp 中
  • 拷贝 temp 到原数组

这里写图片描述

img

代码实现

package ChapterEight;import java.util.Arrays;/**** Author: YZG* Date: 2023/9/13 22:37* Description:*/
public class MergeSort {public static void main(String[] args) {int[] arr = {1, 3, 2, 8, 1, 9};MergeSort.divide(arr,0,arr.length-1);}//分解public static void divide(int[] arr, int left, int right) {if (left < right) {int mid = (left + right) / 2; //中间指针//对左边进行分解divide(arr, left, mid);//对右边进行分解divide(arr, mid + 1, right);//合并conquer(arr, left, mid, right);}}/*** 功能：将俩个部分的子序列进行合并** @param arr   待排序的数组* @param left  指向左子序列的指针* @param mid   指向中间* @param right 指向右子序列的指针*/public static void conquer(int[] arr, int left, int mid, int right) {// 临时数组int[] temp = new int[arr.length];int l = left;int r = mid + 1;int index = 0;//指向临时数组while (l <= mid && r <= right) {if (arr[l] <= arr[r]) {//如果左边的数小于等于右边的数，就将左边的数放到temp中temp[index++] = arr[l++];} else {//相反右边的数小于左边的数，就将右边的数放到temp中temp[index++] = arr[r++];}}//当左边有剩余元素的时候，加到temp中while (l <= mid) {temp[index++] = arr[l++];}//当右边有剩余元素时,加到temp中while (r <= right) {temp[index++] = arr[r++];}//最后将temp数组拷贝到原数组中index = 0;while (left <= right) {arr[left++] = temp[index++];}}
}

五、基数排序

基本思想：分配+收集

也叫桶排序或者箱排序：设置若干个箱子，将关键字为 k 的记录放入第 k 个箱子，然后再按序号将非空的连接。

基数排序： 数字是有范围的，由 0~9 这十个数字组成，则需要设置10个箱子，相继按照 个、十、百…进行排序

【案例演示】

假设对以下序列进行排序

(614，738，921，485，637，101，215，530，790，306)

image-20230913231028498

image-20230913231125164

image-20230913231204854

此时，排序已经完成，需要注意的是，每次进行收集之后，都要将统里面的元素进行清空。

代码实现

  //基数排序public static void radix(int[] arr) {//1、获取数组中最大的数int max = 0;for (int i = 0; i < arr.length; i++) {if (max < arr[i]) {max = arr[i];}}//求最大数的位数int length = (max + "").length();//2、创建10个桶子，分别对应数字0~9.每个桶子的容量为数组的长度int[][] bucket = new int[10][arr.length];//用来表示桶子中数据的个数 比如：count[0] = 3 .表示第一个桶子中有三个数据int[] count = new int[10];for (int i = 0, n = 1; i < length; i++, n = n * 10) {for (int j = 0; j < arr.length; j++) {//3、对数组进行遍历。获取每一个数据的个位数，十位数，百位数int digit = arr[j] / n % 10;//4、按对应的数字放到对应的桶子中,桶子的容量并+1bucket[digit][count[digit]++] = arr[j];}int index = 0; //指向原数组的指针//6、将桶子中的数据依次取出来放回原数组中[共有10个桶子]for (int l = 0; l < 10; l++) {if (count[l] != 0) {//判断桶子中的数据是否等于0for (int k = 0; k < count[l]; k++) {arr[index++] = bucket[l][k];}}//每遍历一个桶，将桶中的数据进行清 0count[l] = 0;}}}

六、各种排序方法的比较

1、时间性能

按平均的时间性能来分，有三类排序方法

时间复杂度为O(nlogn)的方法有:

快速排序、堆排序和归并排序，其中以快速排序为最好

时间复杂度为O(n2)的有

直接插入排序、冒泡排序和简单选择排序，其中以直接插入为最好特别是对那些对关键字近似有序的记录序列尤为如此;

时间复杂度为O(n)的排序方法只有: 基数排序。

2、当待排记录序列按关键字顺序有序时，直接插入排序和冒泡排序能达到 O(n) 的时间复杂度，而对于快速排序而言，这是最不好的情况，此时的时间性能退化为 O(n2)

3、简单选择排序，堆排序和归并排序的时间性能不随记录序列的关键的分布而改变。

image-20230914221330399

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

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Unity 性能优化Shader分析处理函数：ShaderUtil.GetShaderGlobalKeywords用法

Unity 性能优化Shader分析处理函数：ShaderUtil.GetShaderGlobalKeywords用法

Unity 性能优化Shader分析处理函数&#xff1a;ShaderUtil.GetShaderGlobalKeywords用法 点击封面跳转下载页面 简介 Unity 性能优化Shader分析处理函数&#xff1a;ShaderUtil.GetShaderGlobalKeywords用法 在Unity开发中&#xff0c;性能优化是一个非常重要的方面。一个常见…
阅读更多...
华为星闪联盟：引领无线通信技术创新的先锋

华为星闪联盟：引领无线通信技术创新的先锋

星闪&#xff08;NearLink&#xff09;&#xff0c;是由华为倡导并发起的新一代无线短距通信技术&#xff0c;它从零到一全新设计&#xff0c;是为了满足万物互联时代个性化、多样化的极致、创新体验需求而诞生的。这项技术汇聚了中国300多家头部企业和机构的集体智慧&#xff…
阅读更多...
SSM SpringBoot vue快递柜管理系统

SSM SpringBoot vue快递柜管理系统

SSM SpringBoot vue快递柜管理系统 系统功能 登录 注册 个人中心 快递员管理 用户信息管理 用户寄件管理 配送信息管理 寄存信息管理 开发环境和技术 开发语言&#xff1a;Java 使用框架: SSM(Spring SpringMVC Mybaits)或SpringBoot 前端: vue 数据库&#xff1a;Mys…
阅读更多...
使用Spring Gateway为对象存储系统MinIo和kkFileView文档预览增加登录验证

使用Spring Gateway为对象存储系统MinIo和kkFileView文档预览增加登录验证

文章目录 1、kkfileview下载部署1.1、安装包部署运行1.1.1、物理机或虚拟机上运行1.1.2、Docker容器环境环境运行 1.2、接入说明 2、使用Spring Gateway增加登录认证2.1、网关实现代码2.2、文件服务实现代码2.3、Demo运行效果 官网介绍&#xff1a;kkFileView为文件文档在线预览…
阅读更多...
什么是产品架构图？如何绘制产品架构图？

什么是产品架构图？如何绘制产品架构图？

作为一种图形化工具&#xff0c;产品架构图能够以直观的方式展示产品的组成、模块、交互和关系。通过产品架构图&#xff0c;团队成员可以更清晰地了解产品的整体设计&#xff0c;从而更好地协作、沟通和优化。本文将深入探讨产品架构图的关键作用&#xff0c;以及如何高效地创…
阅读更多...
沙丁鱼优化算法(Sardine optimization algorithm,SOA)求解23个函数MATLAB

沙丁鱼优化算法(Sardine optimization algorithm,SOA)求解23个函数MATLAB

一、沙丁鱼优化算法 沙丁鱼优化算法(Sardine optimization algorithm,SOA)由Zhang HongGuang等人于2023年提出&#xff0c;该算法模拟沙丁鱼的生存策略&#xff0c;具有搜索能力强&#xff0c;求解精度高等特点。 沙丁鱼主要以浮游生物为食&#xff0c;这些生物包括细菌、腔肠…
阅读更多...
建设数字孪生智慧城市是未来城市的重要增长点

建设数字孪生智慧城市是未来城市的重要增长点

中国国家创新与发展战略研究会学术委员会常务副主席、重庆市原市长黄奇帆在《瞭望》撰文指出&#xff1a; AI时代的城市是由实体空间和数字空间组成的数字孪生城市&#xff0c;要充分重视对数字空间的治理。随着城市数字化进程的加快&#xff0c;城市、企业、个人开始形成多样化…
阅读更多...
【用unity实现100个游戏之10】复刻经典俄罗斯方块游戏

【用unity实现100个游戏之10】复刻经典俄罗斯方块游戏

文章目录 前言开始项目网格生成Block方块脚本俄罗斯方块基类&#xff0c;绘制方块形状移动逻辑限制移动自由下落下落后设置对应风格为不可移动类型检查当前方块是否可以向指定方向移动旋转逻辑消除逻辑游戏结束逻辑怪物生成源码参考完结 前言 当今游戏产业中&#xff0c;经典游…
阅读更多...
Matlab学习-自定义函数

Matlab学习-自定义函数

Matlab学习-自定义函数 常用自定义函数 文章目录 Matlab学习-自定义函数1. 打印时间2. 计算统计参数3. 画图函数 1. 打印时间 function result calculate_time(time)% Function describe : calculate time% Input : time:N*1% Output : result.hour/min/sec hour/min/sec…
阅读更多...
初始化一个 vite + vue 项目

初始化一个 vite + vue 项目

创建项目 首先使用以下命令创建一个vite项目 npm create vite然后根据提示命令 cd 到刚创建的项目目录下&#xff0c;使用npm install安装所需要的依赖包&#xff0c;再使用npm run dev即可启动项目 配置 vite.config.js 添加process.env配置&#xff0c;如果下面 vue-route…
阅读更多...
【Java基础篇 | 面向对象】—— 继承

【Java基础篇 | 面向对象】—— 继承

个人主页&#xff1a;兜里有颗棉花糖 欢迎 点赞&#x1f44d; 收藏✨ 留言✉ 加关注&#x1f493;本文由 兜里有颗棉花糖 原创 收录于专栏【JavaSE_primary】 本专栏旨在分享学习JavaSE的一点学习心得&#xff0c;欢迎大家在评论区讨论&#x1f48c; 继承允许一个类继承另一个…
阅读更多...
Java8新特性（Stream流）

Java8新特性（Stream流）

Stream流是用于对数组和集合进行便捷操作的。 Stream流 学习Stream流的步骤&#xff1a;获取Stream流&#xff0c;Stream流常见的中间方法&#xff0c;Stream流常见的终结方法。 Stream流的创建 获取数组的Stream流&#xff1a;Arrays.stream(arr)获取List集合的Stream流&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023