基础算法——排序算法（冒泡排序，选择排序，堆排序，插入排序，希尔排序，归并排序，快速排序，计数排序，桶排序，基数排序，Java排序）

1.概述

比较排序算法
算法最好最坏平均空间稳定思想注意事项
冒泡O(n)O( n 2 n^2 n2)O( n 2 n^2 n2)O(1)Y比较最好情况需要额外判断
选择O( n 2 n^2 n2)O( n 2 n^2 n2)O( n 2 n^2 n2)O(1)N比较交换次数一般少于冒泡
堆O( n l o g n nlogn nlogn)O( n l o g n nlogn nlogn)O( n l o g n nlogn nlogn)O(1)N选择堆排序的辅助性较强，理解前先理解堆的数据结构
插入O(n)O( n 2 n^2 n2)O( n 2 n^2 n2)O(1)Y比较插入排序对于近乎有序的数据处理速度比较快，复杂度有所下降，可以提前结束
希尔O(nlogn)O( n 2 n^2 n2)O( n l o g n nlogn nlogn)O(1)N插入gap序列的构造有多种方式，不同方式处理的数据复杂度可能不同
归并O( n l o g n nlogn nlogn)O( n l o g n nlogn nlogn)O( n l o g n nlogn nlogn)O(n)Y分治需要额外的O(n)的存储空间
快速O( n l o g n nlogn nlogn)O( n 2 n^2 n2)O( n l o g n nlogn nlogn)O(logn)N分治快排可能存在最坏情况，需要把枢轴值选取得尽量随机化来缓解最坏情况下的时间复杂度
非比较排序算法
非比较排序算法时间复杂度空间复杂度稳定性
计数排序O(n+k)O(n+k)稳定
桶排序O(n+k)O(n+k)稳定
基数排序O(d*(n+k))O(n+k)稳定

其中

  • n 是数组长度
  • k 是桶长度
  • d 是基数位数
稳定 vs 不稳定

在这里插入图片描述
说明：两个相同的数排序后没有发生改变，说明是稳定的

2.冒泡排序

  • 每轮冒泡不断地比较相邻的两个元素，如果它们是逆序的，则交换它们的位置
  • 下一轮冒泡，可以调整未排序的右边界，减少不必要比较

以数组 3、2、1 的冒泡排序为例，第一轮冒泡
在这里插入图片描述

第二轮冒泡
在这里插入图片描述
未排序区域内就剩一个元素，结束
在这里插入图片描述

public void bubbleSort(int[] nums) {for (int i = 0; i < nums.length - 1; i++) {for (int j = 0; j < nums.length - 1 - i; j++) {if (nums[j] > nums[j + 1]) {int temp = nums[j];nums[j] = nums[j + 1];nums[j + 1] = temp;}}}
}

优化手段：每次循环时，若能确定更合适的右边界，则可以减少冒泡轮数

以数组 3、2、1、4、5 为例，第一轮结束后记录的 x，即为右边界

在这里插入图片描述

public void bubbleSort(int[] nums) {int j = nums.length - 1;while (true) {int x = 0;for (int i = 0; i < j; i++) {if (nums[i] > nums[i + 1]) {int temp = nums[i];nums[i] = nums[i + 1];nums[i + 1] = temp;x = i;}}j = x;if (j == 0) {break;}}
}

3.选择排序

  • 每一轮选择，找出最大（最小）的元素，并把它交换到合适的位置

以下面的数组选择最大值为例
在这里插入图片描述

public void selectSort(int[] nums) {for (int i = 0; i < nums.length - 1; i++) {for (int j = i + 1; j < nums.length; j++) {if (nums[i] > nums[j]) {int temp = nums[i];nums[i] = nums[j];nums[j] = temp;}}}
}

4.堆排序

  • 建立大顶堆
  • 每次将堆顶元素（最大值）交换到末尾，调整堆顶元素，让它重新符合大顶堆特性

建堆
在这里插入图片描述

交换，下潜调整
在这里插入图片描述

public class HeapSort {public static void main(String[] args) {int[] nums = new int[]{3, 2, 1, 4, 5, 7, 9, 6, 8};new HeapSort().heapSort(nums);System.out.println(Arrays.toString(nums));}//堆排序public void heapSort(int[] nums) {//1.建堆操作，符合大顶堆的特性heapify(nums, nums.length);//2.每次将堆顶元素（最大值）交换到末尾，调整堆顶元素，让它重新符合大顶堆特性for (int i = nums.length - 1; i > 0; i--) {swap(nums, 0, i);down(nums, 0, i);//交换完了以后不符合大顶堆的特性}}//建堆private void heapify(int[] nums, int size) {//从倒数第一个非叶子节点开始以此下潜int start = (size - 2) / 2;//非叶子节点的索引for (int i = start; i >= 0; i--) {down(nums, i, size);}}//下潜private void down(int[] nums, int parent, int size) {/*** 方式一：递归实现*//*int left = 2 * parent + 1;int right = 2 * parent + 2;int max = parent;if (left < size && nums[left] > nums[max]) {max = left;}if (right < size && nums[right] > nums[max]) {max = right;}if (parent != max) {swap(nums, parent, max);down(nums, max, size);}*//*** 方式二：循环实现*/while (true) {int left = 2 * parent + 1;int right = 2 * parent + 2;int max = parent;if (left < size && nums[left] > nums[max]) {max = left;}if (right < size && nums[right] > nums[max]) {max = right;}if (parent == max) {break;}swap(nums, parent, max);parent = max;}}//交换private void swap(int[] nums, int i, int j) {int temp = nums[i];nums[i] = nums[j];nums[j] = temp;}
}

5.插入排序

  • 将数组分为两部分 [0 … low-1] [low … a.length-1]
    • 左边 [0 … low-1] 是已排序部分
    • 右边 [low … a.length-1] 是未排序部分
  • 每次从未排序区域取出 low 位置的元素, 插入到已排序区域
    在这里插入图片描述
递归版
public void insertSort(int[] nums) {sort(nums, 1);
}private void sort(int[] nums, int low) {if (low == nums.length) {return;}int t = nums[low];int i = low - 1;while (i >= 0 && t < nums[i]) {nums[i + 1] = nums[i];i--;}if (i != low - 1) {nums[i + 1] = t;}sort(nums, low + 1);
}
非递归版
public void insertSort(int[] nums) {for (int low = 1; low < nums.length; low++) {int t = nums[low];int i = low - 1;while (i >= 0 && t < nums[i]) {nums[i + 1] = nums[i];i--;}if (i != low - 1) {nums[i + 1] = t;}}
}

6.希尔排序

  • 简单的说，就是分组实现插入，每组元素间隙称为 gap
  • 每轮排序后 gap 逐渐变小，直至 gap 为 1 完成排序
  • 对插入排序的优化，让元素更快速地交换到最终位置

下图演示了 gap = 4，gap = 2，gap = 1 的三轮排序前后比较
在这里插入图片描述

public void shellSort(int[] nums) {for (int gap = nums.length >> 1; gap >= 1; gap = gap >> 1) {//原插入排序for (int low = gap; low < nums.length; low++) {int t = nums[low];int i = low - gap;while (i >= 0 && t < nums[i]) {nums[i + gap] = nums[i];i -= gap;}if (i != low - gap) {nums[i + gap] = t;}}}
}

7.归并排序

  • 分 - 每次从中间切一刀，处理的数据少一半
  • 治 - 当数据仅剩一个时可以认为有序
  • 合 - 两个有序的结果，可以进行合并排序

在这里插入图片描述

递归实现
public class MergeSort {public static void main(String[] args) {int[] nums = new int[]{3, 2, 1, 4, 5, 7, 9, 6, 8, 0};new MergeSort().mergeSort(nums);System.out.println(Arrays.toString(nums));}private void mergeSort(int[] nums) {int[] merge = new int[nums.length];split(nums, merge, 0, nums.length - 1);}//对数组进行切分private void split(int[] nums, int[] merge, int left, int right) {if (left == right) {//不可再切了return;}//寻找中间点，以中间点进行切分int mid = (left + right) >>> 1;//切分split(nums, merge, left, mid);split(nums, merge, mid + 1, right);merge(nums, merge, left, mid, mid + 1, right);System.arraycopy(merge, left, nums, left, right - left + 1);}/*** 合并两个有序数组** @param array 原始数组* @param merge 合并后的数组* @param i     第一个有序范围的起始位置* @param iEnd  第一个有序范围的结束位置* @param j     第二个有序范围的起始位置* @param jEnd  第二个有序范围的结束位置*/private void merge(int[] array, int[] merge, int i, int iEnd, int j, int jEnd) {int k = i;while (i <= iEnd && j <= jEnd) {if (array[i] < array[j]) {merge[k] = array[i];i++;} else {merge[k] = array[j];j++;}k++;}if (i > iEnd) {System.arraycopy(array, j, merge, k, jEnd - j + 1);}if (j > jEnd) {System.arraycopy(array, i, merge, k, iEnd - i + 1);}}
}
非递归实现
public class MergeSort {public static void main(String[] args) {int[] nums = new int[]{3, 2, 1, 4, 5, 7, 9, 6, 8, 0};new MergeSort().mergeSort(nums);System.out.println(Arrays.toString(nums));}private void mergeSort(int[] nums) {int length = nums.length;int[] merge = new int[length];//width代表有序区间的宽度，取值是1，2，4，8for (int width = 1; width < length; width *= 2) {//[left,right]代表待合并区间的左右边界for (int left = 0; left < length; left += 2 * width) {int right = Integer.min(2 * width + left - 1, length - 1);int mid = Integer.min(left + width - 1, length - 1);merge(nums, merge, left, mid, mid + 1, right);}//合并数组System.arraycopy(merge, 0, nums, 0, length);}}/*** 合并两个有序数组** @param array 原始数组* @param merge 合并后的数组* @param i     第一个有序范围的起始位置* @param iEnd  第一个有序范围的结束位置* @param j     第二个有序范围的起始位置* @param jEnd  第二个有序范围的结束位置*/private void merge(int[] array, int[] merge, int i, int iEnd, int j, int jEnd) {int k = i;while (i <= iEnd && j <= jEnd) {if (array[i] < array[j]) {merge[k] = array[i];i++;} else {merge[k] = array[j];j++;}k++;}if (i > iEnd) {System.arraycopy(array, j, merge, k, jEnd - j + 1);}if (j > jEnd) {System.arraycopy(array, i, merge, k, iEnd - i + 1);}}
}
归并排序 + 插入排序
  • 小数据量且有序度高时，插入排序效果高
  • 大数据量用归并效果好
  • 可以结合二者
public class MergeInsertSort {public static void main(String[] args) {int[] nums = new int[]{3, 2, 1, 4, 5, 7, 9, 6, 8, 0};new MergeInsertSort().mergeSort(nums);System.out.println(Arrays.toString(nums));}private void mergeSort(int[] nums) {int[] merge = new int[nums.length];split(nums, merge, 0, nums.length - 1);}private void split(int[] nums, int[] merge, int left, int right) {/*** 当元素数量少时，使用插入排序* 之前是切分至剩余一个元素时再合并*/if (right - left < 32) {insertSort(nums, left, right);return;}//寻找中间点，以中间点进行切分int mid = (left + right) >>> 1;//切分split(nums, merge, left, mid);split(nums, merge, mid + 1, right);merge(nums, merge, left, mid, mid + 1, right);System.arraycopy(merge, left, nums, left, right - left + 1);}public void insertSort(int[] nums, int left, int right) {for (int low = left + 1; low <= right; low++) {int t = nums[low];int i = low - 1;while (i >= left && t < nums[i]) {nums[i + 1] = nums[i];i--;}if (i != low - 1) {nums[i + 1] = t;}}}/*** 合并两个有序数组** @param array 原始数组* @param merge 合并后的数组* @param i     第一个有序范围的起始位置* @param iEnd  第一个有序范围的结束位置* @param j     第二个有序范围的起始位置* @param jEnd  第二个有序范围的结束位置*/private void merge(int[] array, int[] merge, int i, int iEnd, int j, int jEnd) {int k = i;while (i <= iEnd && j <= jEnd) {if (array[i] < array[j]) {merge[k] = array[i];i++;} else {merge[k] = array[j];j++;}k++;}if (i > iEnd) {System.arraycopy(array, j, merge, k, jEnd - j + 1);}if (j > jEnd) {System.arraycopy(array, i, merge, k, iEnd - i + 1);}}
}

8.快速排序

单边快排（lomuto分区）
  • 选择最右侧元素作为基准点
  • j 找比基准点小的，i 找比基准点大的，一旦找到，二者进行交换
    • 交换时机：j 找到小的，且与 i 不相等
    • i 找到 >= 基准点元素后，不应自增
  • 最后基准点与 i 交换，i 即为基准点最终索引

例如：
i 和 j 都从左边出发向右查找，i 找到比基准点4大的5，j找到比基准点小的2，停下来交换
在这里插入图片描述

i 找到了比基准点大的5，j 找到比基准点小的3，停下来交换
在这里插入图片描述

j 到达right 处结束，right 与 i 交换，一轮分区结束
在这里插入图片描述

public class QuickSort {public static void main(String[] args) {int[] nums = new int[]{3, 2, 1, 4, 5, 7, 9, 6, 8, 0};new QuickSort().quickSort(nums);System.out.println(Arrays.toString(nums));}/*** 洛穆托分区方案** @param nums*/public void quickSort(int[] nums) {quick(nums, 0, nums.length - 1);}public void quick(int[] nums, int left, int right) {if (left >= right) {return;}int index = partition(nums, left, right);//返回基准点元素的索引quick(nums, left, index - 1);quick(nums, index + 1, right);}//分区操作，返回基准点元素的索引public int partition(int[] nums, int left, int right) {int value = nums[right];//基准点元素int i = left;int j = left;while (j < right) {if (nums[j] < value) {//找到比基准点小的值了if (i != j) {swap(nums, i, j);}i++;}j++;}swap(nums, i, right);return i;}public void swap(int[] nums, int i, int j) {int temp = nums[i];nums[i] = nums[j];nums[j] = temp;}
}
双边快排
  • 选择最左侧元素作为基准点
  • j 找比基准点小的，i 找比基准点大的，一旦找到，二者进行交换
    • i 从左向右
    • j 从右向左
  • 最后基准点与 i 交换，i 即为基准点最终索引

例：

i 找到比基准点大的5停下来，j 找到比基准点小的1停下来（包含等于），二者交换

在这里插入图片描述
i 找到8，j 找到3，二者交换，i 找到7，j 找到2，二者交换
在这里插入图片描述
i == j，退出循环，基准点与 i 交换
在这里插入图片描述

public int partition(int[] nums, int left, int right) {int value = nums[left];//基准点元素int i = left;int j = right;while (i < j) {//j 从右向左找小的while (i < j && nums[j] > value) {j--;}//i 从左向右找大的while (i < j && nums[i] <= value) {i++;}//交换swap(nums, j, i);}swap(nums, left, i);return i;
}

优化

public int partition(int[] nums, int left, int right) {int index = ThreadLocalRandom.current().nextInt(right - left + 1) + left;swap(nums, index, left);int value = nums[left];//随机元素作为基准点元素int i = left;int j = right;while (i < j) {//j 从右向左找小的while (i < j && nums[j] > value) {j--;}//i 从左向右找大的while (i < j && nums[i] <= value) {i++;}//交换swap(nums, j, i);}swap(nums, left, i);return i;
}

解决数组中重复元素

public int partition(int[] nums, int left, int right) {int value = nums[left];//随机元素作为基准点元素int i = left + 1;int j = right;while (i <= j) {//j 从右向左找小的while (i <= j && nums[i] < value) {i++;}//i 从左向右找大的while (i <= j && nums[j] > value) {j--;}if (i <= j) {swap(nums, j, i);i++;j--;}}swap(nums, left, j);return j;
}

9.计数排序

  1. 确定范围：确定待排序数据中的最大值和最小值。
  2. 计数：创建一个计数数组，统计每个元素出现的次数。
  3. 累加计数：将计数数组转化为累加数组，确定每个元素在排序后的位置。
  4. 排序：将元素按照累加数组中的位置放入输出数组。
public void countSort(int[] nums) {//1.找出数组中的最大值与最小值int max = nums[0];int min = nums[0];for (int num : nums) {if (num > max) {max = num;}if (num < min) {min = num;}}//2.创建新数组，长度是 max - min + 1，用来保存原数组中的数据出现的次数int[] count = new int[max - min + 1];for (int num : nums) {count[num - min]++;}//3.循环新数组int k = 0;for (int i = 0; i < count.length; i++) {while (count[i] > 0) {nums[k++] = i + min;count[i]--;}}
}

10.桶排序

public void bucketSort(int[] nums) {//1.创建10个桶，每个桶里保存了一定的序列ArrayList<Integer>[] bucket = new ArrayList[10];//2.初始化for (int i = 0; i < bucket.length; i++) {bucket[i] = new ArrayList<>();}//3.把数据放入桶中for (int num : nums) {bucket[num / 10].add(num);}int k = 0;//4.排序每个桶内元素for (ArrayList<Integer> buck : bucket) {//转数组int[] array = buck.stream().mapToInt(i -> i).toArray();insertSort(array);//插入排序//遍历数组依次放入数组中for (int v : array) {nums[k++] = v;}}
}//插入排序
public void insertSort(int[] nums) {for (int low = 1; low < nums.length; low++) {int i = low - 1;int t = nums[low];while (i >= 0 && t < nums[i]) {nums[i + 1] = nums[i];i--;}if (i != low - 1) {nums[i + 1] = t;}}
}

通用

public void bucketSort(int[] nums, int range) {//1.找出数组中的最大值与最小值int max = nums[0];int min = nums[0];for (int num : nums) {if (num > max) {max = num;}if (num < min) {min = num;}}//1.创建10个桶，每个桶里保存了一定的序列ArrayList<Integer>[] bucket = new ArrayList[(max - min) / range + 1];//2.初始化for (int i = 0; i < bucket.length; i++) {bucket[i] = new ArrayList<>();}//3.把数据放入桶中for (int num : nums) {bucket[(num - min) / range].add(num);}int k = 0;//4.排序每个桶内元素for (ArrayList<Integer> buck : bucket) {//转数组int[] array = buck.stream().mapToInt(i -> i).toArray();insertSort(array);//插入排序//遍历数组依次放入数组中for (int v : array) {nums[k++] = v;}}
}

11.基数排序

基数排序（Radix Sort）是一种非比较型的排序算法，其基本原理是将整数按位数分配，然后按每个位数进行排序。基数排序的稳定性与子排序的稳定性有关。基数排序方法有几种，最常见的是LSD（Least Significant Digit，最低位优先）和MSD（Most Significant Digit，最高位优先）。

public class RadixSort {public static void main(String[] args) {String[] phoneNumbers = new String[]{"13812345678","13912345678","13612345678","13712345678","13512345678","13412345678","15012345678","15112345678","15212345678","15712345678"};new RadixSort().radixSort(phoneNumbers, 3);System.out.println(Arrays.toString(phoneNumbers));}public void radixSort(String[] nums, int length) {//1.准备10个桶并初始化ArrayList<String>[] buckets = new ArrayList[10];for (int i = 0; i < buckets.length; i++) {buckets[i] = new ArrayList<>();}//2.依次把数据放入桶内for (int i = length - 1; i >= 0; i--) {for (String num : nums) {buckets[num.charAt(i) - 48].add(num);}int k = 0;for (ArrayList<String> bucket : buckets) {for (String s : bucket) {nums[k++] = s;}bucket.clear();}}}
}

12.Java排序

Arrays.sort

JDK 7~13 中的排序实现

排序目标条件采用算法
int[] long[] float[] double[]size < 47混合插入排序 (pair)
size < 286双基准点快排
有序度低双基准点快排
有序度高归并排序
byte[]size <= 29插入排序
size > 29计数排序
char[] short[]size < 47插入排序
size < 286双基准点快排
有序度低双基准点快排
有序度高归并排序
size > 3200计数排序
Object[]-Djava.util.Arrays.useLegacyMergeSort=true传统归并排序
TimSort

JDK 14~20 中的排序实现

排序目标条件采用算法
int[] long[] float[] double[]size < 44 并位于最左侧插入排序
size < 65 并不是最左侧混合插入排序 (pin)
有序度低双基准点快排
递归次数超过 384堆排序
对于整个数组或非最左侧 size > 4096，有序度高归并排序
byte[]size <= 64插入排序
size > 64计数排序
char[] short[]size < 44插入排序
再大双基准点快排
递归次数超过 384计数排序
size > 1750计数排序
Object[]-Djava.util.Arrays.useLegacyMergeSort=true传统归并排序
TimSort
  • 其中 TimSort 是用归并+二分插入排序的混合排序算法
  • 值得注意的是从 JDK 8 开始支持 Arrays.parallelSort 并行排序
  • 根据最新的提交记录来看 JDK 21 可能会引入基数排序等优化
LeetCode题目

1题
912题
在这里插入图片描述

1122题
1636题
164题

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

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

相关文章

利用pythonstudio写的PDF、图片批量水印生成器，可同时为不同读者生成多组水印

利用pythonstudio写的PDF、图片批量水印生成器，可同时为不同读者生成多组水印

现在很多场合需要将PDF或图片加水印&#xff0c;本程序利用pythonstudio编写。 第一步 界面 其中&#xff1a; LstMask:列表框 PopupMenu:PmnMark LstFiles:列表框 PopupMenu:PmnFiles OdFiles:文件选择器 Filter:PDF文件(.PDF)|.PDF|图像文件(.JPG)|.JPG|图像文件(.png…
阅读更多...
如何区分实例化网格中的每个实例

如何区分实例化网格中的每个实例

1&#xff09;如何区分实例化网格中的每个实例 2&#xff09;项目在模拟器上切换程序后有概率画面冻结 3&#xff09;Unity工程导入团结引擎&#xff0c;GUID会变化&#xff0c;导致引用关系丢失 4&#xff09;Mask在Android平台下渲染异常 这是第407篇UWA技术知识分享的推送&a…
阅读更多...
前端前置——ajax

前端前置——ajax

目标&#xff1a;使用axios库&#xff0c;获取省份列表数据&#xff0c;展示到页面上 axios库地址&#xff1a;https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js 省份数据地址&#xff1a;http://hmajax.itheima.net/api/province axios的使用 axios({ url:目标资源地…
阅读更多...
oasys系统代码审计

oasys系统代码审计

简述&#xff1a; oasys是一个OA办公自动化系统&#xff0c;使用Maven进行项目管理&#xff0c;基于springboot框架开发的项目&#xff0c;mysql底层数据库&#xff0c;前端采用freemarker模板引擎&#xff0c;Bootstrap作为前端UI框架&#xff0c;集成了jpa、mybatis等框架。…
阅读更多...
书生大模型第三关Git 基础知识

书生大模型第三关Git 基础知识

关卡编号&#xff1a;L0G3000 任务一 破冰行动 fork仓库&#xff0c;注意这里不要勾选Copy branch Only!!!&#xff0c;因为后面课程中会使用到class分支&#xff1a; 克隆仓库&#xff1a; 移动分支&#xff1a; 创建自己的分支&#xff1a; 创建id.md文档&#xff0c;…
阅读更多...
在vue3的vite网络请求报错 [vite] http proxy error:

在vue3的vite网络请求报错 [vite] http proxy error:

在开发的过程中 代理proxy报错: [vite] http proxy error: /ranking/hostRank?dateType1 Error: connect ETIMEDOUT 43.xxx.xxx.xxx:443 网络请求是http的: // vite.config.ts import { Agent } from node:http;server: {host: 0.0.0.0,port: port,open: true,https: false,…
阅读更多...
初识HTML

初识HTML

什么是HTML呢&#xff1f; HTML是超文本标记语言&#xff0c;HTML代码是由“标签”构成的 超文本&#xff1a;文本、声音、图片、视频、表格、链接 标记&#xff1a;由许许多多的标签组成 HTML页面是运行到浏览器上面的 第一个HTML程序 和C语言从hello world开始一样 HTML可…
阅读更多...
DevOps-课堂笔记

DevOps-课堂笔记

各种 aaS 类比于计算机网络的 OSI 参考模型&#xff0c;一个软件应用项目需要不同的支撑层&#xff0c;例如从下至上大概需要&#xff1a; 硬件层面的服务器针对硬件做弹性分配的虚拟化机制&#xff0c;例如虚拟机在虚拟化环境内运行的 OS支撑软件应用的中间件&#xff0c;例…
阅读更多...
AnatoMask的分层图像编码器-解码器

AnatoMask的分层图像编码器-解码器

方法思想 采用多尺度编码器-解码器主干&#xff1a; 在编码器中&#xff0c;把CT图像分解成不同大小的图像块&#xff0c;从这些图像块中提取特征在解码器中&#xff0c;重建被掩盖图像时&#xff0c;考虑图像块的空间关系 输入D&#xff08;深度Depth&#xff09;张H&#x…
阅读更多...
C++ 之boost/date_time/posix_time高精度计时详细总结

C++ 之boost/date_time/posix_time高精度计时详细总结

文章目录 概要时间长度类time_duration时间点ptime时间区域time_period时间迭代器实际应用1&#xff1a;&#xff08;计算加速度&#xff09;实际应用2&#xff1a;可以支持秒级和微秒/纳秒级计时器 概要 使用date_time库需要在编译时加上"-lboost_date_time"&#x…
阅读更多...
小语言模型介绍与LLM的比较

小语言模型介绍与LLM的比较

小模型介绍 小语言模型&#xff08;SLM&#xff09;与大语言模型&#xff08;LLM&#xff09;相比&#xff0c;具有不同的特点和应用场景。大语言模型通常拥有大量的参数&#xff08;如 GPT-3 拥有 1750 亿个参数&#xff09;&#xff0c;能够处理复杂的自然语言任务&#xff…
阅读更多...
Kafka 可观测性最佳实践

Kafka 可观测性最佳实践

Kafka 概述 Kafka 是由 LinkedIn 开发一个分布式的基于发布订阅模式的消息队列&#xff0c;是一个实时数据处理系统&#xff0c;可以横向扩展。与 RabbitMQ、RockerMQ 等中间件一样拥有几大特点&#xff1a; 异步处理服务解耦流量削峰 监控 Kafka 是非常重要的&#xff0c;因…
阅读更多...
混合式学习平台：企业培训的新选择

混合式学习平台：企业培训的新选择

在当前的商业环境中&#xff0c;企业普遍采用在线直播课程进行员工培训。然而&#xff0c;在线学习常常伴随着焦虑、疲劳和效率低下等问题&#xff0c;这些都是企业在进行在线培训时需要面对和解决的挑战。本文将探讨如何通过使用白板协作工具——即时白板&#xff0c;来提高企…
阅读更多...
内网项目，maven本地仓库离线打包，解决Cannot access central in offline mode?

内网项目，maven本地仓库离线打包，解决Cannot access central in offline mode?

背景&#xff1a; 内网项目打包&#xff0c;解决Cannot access central in offline mode? 1、修改maven配置文件&#xff1a; localRepository改为本地仓库位置 <localRepository>D:\WorkSpace\WorkSoft\maven-repository\iwhalecloud-repository\business</loca…
阅读更多...
如何用 ChatPaper.ai 打造完美的 AI 课堂笔记系统

如何用 ChatPaper.ai 打造完美的 AI 课堂笔记系统

作为学生&#xff0c;我们都遇到过这样的困扰&#xff1a;上课时记笔记太投入就听不进讲解&#xff0c;专注听讲又担心错过重要知识点。有了AI助手&#xff0c;这个问题就可以优雅地解决了。今天跟大家分享如何用ChatPaper.ai构建个人的智能课堂笔记系统。 为什么需要AI辅助记笔…
阅读更多...
雷池社区版 7.1.0 LTS 发布了

雷池社区版 7.1.0 LTS 发布了

LTS&#xff08;Long Term Support&#xff0c;长期支持版本&#xff09;是软件开发中的一个概念&#xff0c;表示该版本将获得较长时间的支持和更新&#xff0c;通常包含稳定性、性能改进和安全修复&#xff0c;但不包含频繁的新特性更新。 作为最受欢迎的社区waf&#xff0c…
阅读更多...
C语言心型代码解析

C语言心型代码解析

方法一 心型极坐标方程 爱心代码你真的理解吗 笛卡尔的心型公式&#xff1a; for (y 1.5; y > -1.5; y - 0.1) for (x -1.5; x < 1.5; x 0.05) 代码里面用了二个for循环&#xff0c;第一个代表y轴&#xff0c;第二个代表x轴 二个增加的单位不同&#xff0c;能使得…
阅读更多...
【云原生开发】如何通过client-go来操作K8S集群

【云原生开发】如何通过client-go来操作K8S集群

✨✨ 欢迎大家来到景天科技苑✨✨ &#x1f388;&#x1f388; 养成好习惯&#xff0c;先赞后看哦~&#x1f388;&#x1f388; &#x1f3c6; 作者简介&#xff1a;景天科技苑 &#x1f3c6;《头衔》&#xff1a;大厂架构师&#xff0c;华为云开发者社区专家博主&#xff0c;…
阅读更多...
开源协议类型及长安链开源协议介绍

开源协议类型及长安链开源协议介绍

截至目前&#xff0c;我国参与国际开源社区协作的开发者数量排名全球第二并推出了众多社区活跃度较高的高质量开源项目&#xff0c;是全球开源生态的重要贡献力量&#xff0c;但在开源治理方面我国还处于发展初期&#xff0c;大部分开发者对开源的印象还限于开放代码、免费使用…
阅读更多...
计算机网络：网络层 —— 边界网关协议 BGP

计算机网络：网络层 —— 边界网关协议 BGP

文章目录 路由选择协议动态路由协议边界网关协议 BGPBGP 的基本概念BGP-4 的四种报文 路由选择协议 因特网是全球最大的互联网&#xff0c;它所采取的路由选择协议具有以下三个主要特点&#xff1a; 自适应&#xff1a;因特网采用动态路由选择&#xff0c;能较好地适应网络状态…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023