Java_排序

文章目录

  • 一、排序的概念
  • 二、常见的排序算法
  • 三、常见排序算法的实现
    • 1.插入排序
      • 1、基本思想
      • 2、直接插入排序
      • 3、希尔排序（缩小增量排序）
    • 2.选择排序
      • 1、基本思想
      • 2、直接选择排序
      • 2、堆排序
    • 3.交换排序
      • 1、冒泡排序
      • 2、快速排序
      • 3、快速排序优化
      • 4、快速排序非递归
    • 4.归并排序
      • 1、基本思想
      • 2、海量数据的排序问题
  • 四、排序算法复杂度及稳定性分析
  • 五、练习

一、排序的概念

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
在这里插入图片描述
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

二、常见的排序算法

在这里插入图片描述

三、常见排序算法的实现

1.插入排序

1、基本思想

直接插入排序是一种简单的插入排序法，其基本思想是：
把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。

2、直接插入排序

当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移
在这里插入图片描述
时间复杂度:
最坏情况下：O(n^2)
最好情况下：O(n) 当数据越有序，排序越快
适用于：待排序序列 已经基本上趋于有序了
空间复杂度：
O(1)
稳定性：
稳定

逻辑：
假设这组数据的第一个元素是有序的，从第二个元素开始，依次和前面的元素进行比较找到合适的位置就进行插入。

代码实现：

    public static void insertSort(int[] array){if(array==null||array.length<=1){return;}for(int end = 1;end<array.length;end++){int temp  = array[end];int cur = end-1;while(cur>=0){if(array[cur]>temp){array[cur+1] =array[cur];cur--;}else{break;}}array[cur+1] = temp;}}

测试代码：

    public static void main(String[] args) {int [] array ={27,15,9,18,28};insertSort(array);System.out.println(Arrays.toString(array));}

在这里插入图片描述

3、希尔排序（缩小增量排序）

希尔排序法又称缩小增量法。希尔排序法的基本思想是：
先选定一个整数，把待排序文件中所有记录分成多个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
在这里插入图片描述
gap = 5 和 gap = 3是预排序，每组插入排序的优点是越有序越快，当gap = 5时，每组数据少，当gap = 3越来越有序了，直到gap =1时，虽然数据量大了，但也有序了。

希尔排序的特性总结：

  1. 希尔排序是对直接插入排序的优化。
  2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
  3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，暂时按照O(n1.25)到O(1.6*n1.25)
  4. 稳定性：不稳定

代码实现：

    public static void shellSort(int [] array){int gap = array.length;while(gap>1){gap /=2;shell(array,gap);}}public static void shell(int [] array,int gap){for(int end = gap;end<array.length;end++){int temp  = array[end];int cur = end-gap;while(cur>=0){if(array[cur]>temp){array[cur+gap] = array[cur];cur-=gap;}else{break;}}array[cur+gap] = temp;}}

测试代码：

    public static void main(String[] args) {int [] array ={27,15,9,18,28,-100};
//        insertSort(array);shellSort(array);System.out.println(Arrays.toString(array));}

在这里插入图片描述

2.选择排序

1、基本思想

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

2、直接选择排序

在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

直接选择排序的特性总结：

  1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定
    代码实现：
    public  static void selectSort(int []array){int len = array.length;for(int end = len-1;end>0;end--){int maxIndex = 0;for(int cur = 0;cur<=end;cur++){if(array[maxIndex]<array[cur]){maxIndex = cur;}}int temp = array[end];array[end] = array[maxIndex];array[maxIndex] =temp;}}

优化：
可以在一次遍历时，记录最小值的引索和最大值的引索，这是双向选择。

代码实现：

    public  static void selectSort2(int []array){int len = array.length;for(int begin = 0,end = len-1;begin<end;begin++,end--){int maxIndex = begin;int minIndex = begin;int cur = begin;while(cur<=end){if(array[maxIndex]<array[cur]){maxIndex = cur;}if(array[minIndex]>array[cur]){minIndex = cur;}cur++;}if(maxIndex == begin){maxIndex = minIndex;}swap(array,begin,minIndex);swap(array,end,maxIndex);}}public static void swap(int [] array,int i,int j){int temp = array[i];array[i] = array[j];array[j]  =temp;}

注意：
最后交换位置的时候，最小位置和最小引索交换，可能会导致最大值被换到其他位置，所以要在交换前检查 maxIndex和begin是否一样。

2、堆排序

堆排序（Heapsort）是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。　
在这里插入图片描述
堆排序的特性总结：

  1. 堆排序使用堆来选数，效率就高了很多。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定
    代码实现：
    public static void createHeap(int [] array){int len  = array.length;for(int cur =(len-1-1)/2;cur>=0;cur--){siftDown(array,cur,len);}}public static void heapSort(int [] array){createHeap(array);for(int end = array.length-1;end>0;end--){swap(array,0,end);siftDown(array,0,end);}}public static void siftDown(int [] array,int parent,int useSize){int child = parent*2+1;while(child<useSize){if(child+1<useSize&&array[child+1]>array[child]){child = child+1;}if(array[parent]<array[child]){swap(array,parent,child);parent = child;child = parent*2+1;}else{break;}}}

测试代码：

    public static void main(String[] args) {int [] array ={ 100,27,15,9,18,28,-100,20};
//        insertSort(array);
//        shellSort(array);
//        selectSort(array);
//        selectSort2(array);heapSort(array);System.out.println(Arrays.toString(array));}

在这里插入图片描述

3.交换排序

基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动

1、冒泡排序

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。
请添加图片描述

冒泡排序的特性总结：

  1. 冒泡排序是一种非常容易理解的排序
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)
  4. 稳定性：稳定

冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。

代码实现：

    public static void bubbleSort(int[] array){for(int i = 0;i<array.length-1;i++){boolean flag = true;for(int j = 1;j<array.length-i;j++){if(array[j]<array[j-1]){swap(array,j,j-1);flag  = false;}}if(flag){break;}}}

测试代码：

    public static void main(String[] args) {int [] array ={ 100,27,15,9,18,28,-100,20};int [] array2 = {1,2,3,4,5};
//        insertSort(array);
//        shellSort(array);
//        selectSort(array);
//        selectSort2(array);
//        heapSort(array);bubbleSort(array);bubbleSort(array2);System.out.println(Arrays.toString(array));System.out.println(Arrays.toString(array2));}

在这里插入图片描述

2、快速排序

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

快速排序总结：

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(logN)
  4. 稳定性：不稳定

代码实现Hoare版本：

     public static void quickSort(int [] array){quick(array,0,array.length-1);}public static void quick(int[]array,int start,int end ){if(start>=end){return;}int pivot = partitionHoare(array,start,end);quick(array,start,pivot-1);quick(array,pivot+1,end);}private static int partitionHoare(int[] array, int left, int right) {int temp = array[left];int i = left;while(left<right){//找小于tempwhile(left<right && array[right]>=temp){right--;}//找大于tempwhile(left<right && array[left]<=temp){left++;}swap(array,left,right);}swap(array,i,left);return left;}

代码实现挖坑法：

     public static void quickSort(int [] array){quick(array,0,array.length-1);}public static void quick(int[]array,int start,int end ){if(start>=end){return;}int pivot = partitionHole(array,start,end);quick(array,start,pivot-1);quick(array,pivot+1,end);}private static int partitionHole(int[] array, int left, int right) {int temp = array[left];while(left<right){if(left<right&&array[right]>=temp){right--;}array[left] = array[right];//现在坑变成rightif(left<right&&array[left]<=temp){left++;}array[right] =array[left];}array[left] =temp;return left;}

思考：

  1. 为什么array[right]>=temp 和array[left]<=temp要取=？
    会造成死循环

  2. 为什么先从右边而不是先从左边？
    对于Hoare法，如果先走左边有可能出现相遇的是大的数据，最后把大的数据放到了最前面。

代码实现前后指针：

     public static void quickSort(int [] array){quick(array,0,array.length-1);}public static void quick(int[]array,int start,int end ){if(start>=end){return;}int pivot = partitionD(array,start,end);quick(array,start,pivot-1);quick(array,pivot+1,end);}private static int partitionD(int[] array, int left, int right) {int temp = array[left];int prev = left;int cur = left+1;//[left,prev]是<=temp//[prev+1,cur)是>temp//[cur,right]是待排while(cur<=right){if(array[cur]>temp){cur++;}else{swap(array,++prev,cur++);}}swap(array,left,prev);return  prev;}

3、快速排序优化

出发点：减少递归次数

  1. 三数取中法选key
  2. 递归到小的子区间时，可以考虑使用插入排序

优化后的代码：

 public static void insertSort(int[] array,int left,int right){if(array==null||array.length<=1){return;}for(int end = left+1;end<=right;end++){int temp  = array[end];int cur = end-1;while(cur>=0){if(array[cur]>temp){array[cur+1] =array[cur];cur--;}else{break;}}array[cur+1] = temp;}}public static void quickSort(int [] array){quick(array,0,array.length-1);}public static void quick(int[]array,int start,int end ){if(end-start+1<3){insertSort(array,start,end);return;}int mid = middleNum(array,start,end);swap(array,mid,start);int pivot = partitionD(array,start,end);quick(array,start,pivot-1);quick(array,pivot+1,end);}public  static int middleNum(int [] array,int left,int right){int mid  = (left+right)/2;if(array[left]<array[right]){if(array[mid]<array[left]){return left;}else if(array[mid]>array[right]){return right;}else{return mid;}}else{//left>rightif(array[mid]>array[left]){return left;}else  if(array[mid]<array[right]){return right;}else{return mid;}}}private static int partitionD(int[] array, int left, int right) {int temp = array[left];int prev = left;int cur = left+1;//[left,prev]是<=temp//[prev+1,cur)是>temp//[cur,right]是待排while(cur<=right){if(array[cur]>temp){cur++;}else{swap(array,++prev,cur++);}}swap(array,left,prev);return  prev;}

4、快速排序非递归

把划分两个区间的左右边界存到栈里，不断拿出区间快排，划分两个区间，存入栈里，直到栈为空时，即表示数组排完。

快速排序总结

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(logN)
  4. 稳定性：不稳定
    代码实现：
    public static void quickSortNonR(int[] array, int left, int right) {Stack<Integer> stack = new Stack<>();stack.push(left);stack.push(right);while(!stack.isEmpty()){int end = stack.pop();int begin = stack.pop();if(begin>=end){continue;}int mid = middleNum(array,begin,end);swap(array,begin,mid);int key = array[begin];int prev = begin;int cur = prev+1;//[begin,prev] 是<=key//[prev,cur)是>key//[cur,end]是待排序列while(cur<=end){if(array[cur]<key){swap(array,++prev,cur++);}else{cur++;}}swap(array,begin,prev);if(prev-1>begin){stack.push(begin);stack.push(prev-1);}if(prev+1<end){stack.push(prev+1);stack.push(end);}}}public static void swap(int [] array,int i,int j){int temp = array[i];array[i] = array[j];array[j]  =temp;}public  static int middleNum(int [] array,int left,int right){int mid  = (left+right)/2;if(array[left]<array[right]){if(array[mid]<array[left]){return left;}else if(array[mid]>array[right]){return right;}else{return mid;}}else{//left>rightif(array[mid]>array[left]){return left;}else  if(array[mid]<array[right]){return right;}else{return mid;}}}

测试代码：

    public static void main(String[] args) {int [] array ={ 100,27,15,9,18,28,-100,20};quickSortNonR(array,0,array.length-1);System.out.println(Arrays.toString(array));}

在这里插入图片描述

4.归并排序

1、基本思想

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序核心步骤：
在这里插入图片描述
归并排序总结

  1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(N)
  4. 稳定性：稳定
    递归代码实现：
  public static void mergeSort(int []array){mergeSortFun(array,0,array.length-1);}public static void mergeSortFun(int[] array, int left, int right) {if(left>=right){return;}int mid = (left+right)/2;mergeSortFun(array,left,mid);mergeSortFun(array,mid+1,right);merge(array,left,mid,right);}public static void merge(int[] array,int left,int mid ,int right){int capacity = right-left+1;int [] temp = new int [capacity];int begin1 = left;int begin2 = mid+1;int k = 0;while(begin1<=mid&&begin2<=right){if(array[begin1]<=array[begin2]){temp[k++] = array[begin1++];}else{temp[k++] =array[begin2++];}}while(begin1<=mid){temp[k++] = array[begin1++];}while(begin2<=right){temp[k++] = array[begin2++];}for(int i = 0;i<k;i++){array[i+left] = temp[i];}}

归并排序非递归代码实现：

    public static void mergeSortNor(int [] array){int gap = 1;while(gap<array.length){for(int i = 0;i<array.length;i+=2*gap){int left = i;
//                int mid = left+gap-1;
//                int right = mid+gap;int mid = Math.min(left+gap-1,array.length-1);int right = Math.min(mid + gap, array.length - 1);int [] temp  = new int [2*gap];int k = 0;int begin1 = left;int begin2 = mid+1;while(begin1<=mid&&begin2<=right){if(array[begin1]<array[begin2]){temp[k++] =  array[begin1++];}else {temp[k++] =array[begin2++];}}while (begin1<=mid){temp[k++]=array[begin1++];}while (begin2<=right){temp[k++] = array[begin2++];}for(int j = 0;j<k;j++){array[left+j] = temp[j];}}gap*=2;}}

2、海量数据的排序问题

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

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

四、排序算法复杂度及稳定性分析

在这里插入图片描述

O(n^2) O(n^2) O(1) 稳定
选择排序 O(n^2) O(n^2) O(n^2) O(1) 不稳定
希尔排序 O(n) O(n^1.3) O(n^2) O(1) 不稳定
堆排序 O(n * log(n)) O(n * log(n)) O(n * log(n)) O(1) 不稳定
快速排序 O(n * log(n)) O(n * log(n)) O(n^2) O(log(n)) ~ O(n) 不稳定
归并排序 O(n * log(n)) O(n * log(n)) O(n * log(n)) O(n) 稳定

排序方法最好平均最坏空间复杂度稳定性
冒泡排序O(n)O(n^2)O(n^2)O(1)稳定
插入排序O(n)O(n^2)O(n^2)O(1)稳定
选择排序O(n^2)O(n^2)O(n^2)O(1)不稳定
希尔排序O(n)O(n^1.3)O(n^2)O(1)不稳定
堆排序O(n*logn)O(n*logn)O(n*logn)O(1)不稳定
快速排序O(n*logn)O(n*logn)O(n^2)O(long(n))~O(n)不稳定
归并排序O(n*logn)O(n*logn)O(n*logn)O(n)稳定

五、练习

题目：

1. 快速排序算法是基于()的一个排序算法。
A：分治法 B：贪心法 C：递归法 D：动态规划法
2.对记录（54,38,96,23,15,72,60,45,83）进行从小到大的直接插入排序时，当把第8个记录45插入到有序表时，为找到插入
位置需比较()次？（采用从后往前比较）
A: 3 B: 4 C: 5 D: 6
3.以下排序方式中占用O(n)辅助存储空间的是()
A: 简单排序 B: 快速排序 C: 堆排序 D: 归并排序
4.下列排序算法中稳定且时间复杂度为O(n^2)的是()
A: 快速排序 B: 冒泡排序 C: 直接选择排序 D: 归并排序
5.关于排序，下面说法不正确的是()
A: 快排时间复杂度为O(N*logN)，空间复杂度为O(logN)
B: 归并排序是一种稳定的排序,堆排序和快排均不稳定
C: 序列基本有序时，快排退化成 "冒泡排序"，直接插入排序最快
D: 归并排序空间复杂度为O(N), 堆排序空间复杂度的为O(logN)
6.设一组初始记录关键字序列为(65,56,72,99,86,25,34,66)，则以第一个关键字65为基准而得到的一趟快速排序结果是（）
A: 34，56，25，65，86，99，72，66 B: 25，34，56，65，99，86，72，66
C: 34，56，25，65，66，99，86，72 D: 34，56，25，65，99，86，72，66

答案：

1.A 2.C 3.D 4.B 5.D 6.A

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

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

相关文章

JVM-垃圾收集器

JVM-垃圾收集器

名词解释 并行和并发 并行与并发在垃圾回收上的含义 并行&#xff08;Parallel&#xff09;&#xff1a;指多条垃圾收集线程并行工作&#xff0c;但此时用户线程仍然处于等待状态。并发&#xff08;Concurrent&#xff09;&#xff1a;指用户线程与垃圾收集线程同时执行&…
阅读更多...
网络编程(3/6)

网络编程(3/6)

使用C语言完成数据库的增删改 #include<myhead.h> int do_add(sqlite3 *ppDb) {int numb;char name[50];int salary;printf("请输入员工信息&#xff1a;工号、姓名、薪水\n");scanf("%d %s %d",&numb,name,&salary);char sql[128];char *e…
阅读更多...
【Leetcode】top 100 双指针

【Leetcode】top 100 双指针

283 移动零 给定一个数组 nums&#xff0c;编写一个函数将所有 0 移动到数组的末尾&#xff0c;同时保持非零元素的相对顺序。 分析&#xff1a;双指针初始为0&#xff1b;left指针找零值&#xff0c;right指针找非零值&#xff1b;由于需要保持非零元素的相对顺序&#xff0c…
阅读更多...
VUE3 显示Echarts百度地图

VUE3 显示Echarts百度地图

本次实现最终效果 技术基础以及环境要求 vue3 echarts 百度地图API 要求1&#xff1a; VUE3 环境搭建&#xff1a;https://blog.csdn.net/LQ_001/article/details/136293795 要求2&#xff1a; VUE3 echatrs 环境搭建:https://blog.csdn.net/LQ_001/article/details/1363…
阅读更多...
【MATLAB第98期】基于MATLAB的MonteCarlo蒙特卡罗结合kriging克里金代理模型的全局敏感性分析模型【更新中】

【MATLAB第98期】基于MATLAB的MonteCarlo蒙特卡罗结合kriging克里金代理模型的全局敏感性分析模型【更新中】

【MATLAB第98期】基于MATLAB的Monte Carlo蒙特卡罗结合kriging克里金代理模型的全局敏感性分析模型【更新中】 PS:因内容涉及较多&#xff0c;所以一时半会更新不完 后期会将相关原理&#xff0c;以及多种功能详细介绍。 麻烦点赞收藏&#xff0c;及时获取更新消息。 引言 在…
阅读更多...
Go编程实战：高效利用encoding/binary进行数据编解码

Go编程实战：高效利用encoding/binary进行数据编解码

Go编程实战&#xff1a;高效利用encoding/binary进行数据编解码 引言encoding/binary 包核心概念ByteOrder 接口Binary 数据类型的处理处理复杂数据结构 基础使用教程数据类型与二进制格式的映射基本读写操作写操作 - binary.Write读操作 - binary.Read 错误处理 高级功能与技巧…
阅读更多...
定时执行专家V7.1 多国语言版本日文版发布 - タスク自動実行ツールV7.1 日本語版リリース

定时执行专家V7.1 多国语言版本日文版发布 - タスク自動実行ツールV7.1 日本語版リリース

◆ 软件介绍　　ソフトの紹介 《定时执行专家》是一款制作精良、功能强大、毫秒精度、专业级的定时任务执行软件。软件具有 25 种【任务类型】、12 种【触发器】触发方式&#xff0c;并且全面支持界面化【Cron表达式】设置。软件采用多线程并发方式检测任务触发和任务执行&…
阅读更多...
CentOS7 Sqoop 1.4.7 安装 (Hadoop 3.3.0)

CentOS7 Sqoop 1.4.7 安装 (Hadoop 3.3.0)

CentOS7 Sqoop 1.4.7 安装 (Hadoop 3.3.0) 1、 Sqoop 1.4.7 官网链接下载&#xff1a; https://archive.apache.org/dist/sqoop/1.4.7/ 2、把压缩包用mobaxterm拖到 /tools文件夹 3、解压 tar -zvxf /tools/sqoop-1.4.7.bin__hadoop-2.6.0.tar.gz -C /training/4、进入 /t…
阅读更多...
基于深度学习的交通标志检测识别系统（含UI界面、yolov8、Python代码、数据集）

基于深度学习的交通标志检测识别系统（含UI界面、yolov8、Python代码、数据集）

项目介绍 项目中所用到的算法模型和数据集等信息如下&#xff1a; 算法模型&#xff1a;     yolov8 yolov8主要包含以下几种创新&#xff1a;         1. 添加注意力机制&#xff08;SE、CBAM等&#xff09;         2. 修改可变形卷积&#xff08;DySnake-主干c…
阅读更多...
moi3D安装

moi3D安装

下载文件双击文件 下一步 同意下一步 下一步 下一步 下一步 安装下一步 完成 破解 将如图中的文件复制到文件目录下 汉化 在目录中进入ui文件夹下 在安装包中找到如下的文件复制到ui目录下 在打开 另存为 另存为时改一下编码格式如图 打开软件 找到如图options进入…
阅读更多...
蓝牙 | 软件： Qualcomm BT Audio 问题分析(4)----检查MIPS使用情况

蓝牙 | 软件： Qualcomm BT Audio 问题分析(4)----检查MIPS使用情况

大家好&#xff01; 我是“声波电波还看今朝”成员的一位FAE Devin.wen&#xff0c;欢迎大家关注我们的账号。 今天给大家大概讲解“如何排查Qualcomm BT Audio”的疑难杂症&#xff08;四&#xff09;&#xff1a;MIPS检查。 如果大家还没有注册我们大大通的账号&#xff0c…
阅读更多...
Spring AOP(二) — 底层组件

Spring AOP(二) — 底层组件

Spring AOP 是通过动态代理的方式来实现&#xff0c;主要是通过Pointcut、Advice、Advisor及ProxyFactoryBean 等接口来创建代理对象。 在IoC容器中&#xff0c;Advice 是一个bean&#xff08;这样可以在通知中使用其他的bean&#xff09;&#xff0c;而Pointcut虽然不是一个B…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023