（java版）排序算法----【冒泡，选择，插入，希尔，快速排序，归并排序，基数排序】超详细~~

目录

冒泡排序(BubbleSort)：

代码详解：

 冒泡排序的优化：

 选择排序(SelectSort)：

代码详解：

 插入排序（InsertSort）：

代码详解：

 希尔排序(ShellSort)：

 法一（交换法）代码详解：

 法二（移位法-->插入排序的优化）代码详解：

快速排序（QuickSort）： 

代码详解：

 归并排序（MergetSort）：

代码详解：

 基数排序（RadixSort）：

代码详解：

最后，一张图概括： 

冒泡排序(BubbleSort)：

冒泡排序（BubbleSort）的基本思路：通过对待排序从前往后（从下标较小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前往后移动，较小的往上挪动，就像水底下的气泡一样逐渐向上冒。

图解：

代码详解：

public class BubbleSort {public static void main(String[] args){Scanner sc=new Scanner(System.in);int[] arr=new int[5];//假设测试案例只有五个数字System.out.print("请输入要排序的数组：");for(int i=0;i<5;i++){arr[i]=sc.nextInt();}bubblesort(arr);System.out.println();System.out.print("请输出排序好的数组："+Arrays.toString(arr));}public static void bubblesort(int[] arr){for(int i=0;i<arr.length-1;i++){for(int j=0;j<arr.length-1-i;j++){if(arr[j]>arr[j+1]){int temp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;}}System.out.printf("第%d趟排序后的数组",i+1);//展示每次冒泡排序的过程System.out.println(Arrays.toString(arr));//将数组转化为字符串的形式输出}}
}

运行结果：（通过运行结果来展示“气泡”向上挪动的过程，较大的数逐渐沉底）

 冒泡排序的优化：

因为排序的过程中，各个元素不断接近自己要排好时所对应的位置，如果一趟比较下来没有进行交换，就说明序列有序。通过设置一个标志flag判断元素是否进行过交换，从而减少不必要的比较。

优化代码：

// 将前面额冒泡排序算法，封装成一个方法
public static void bubbleSort(int[] arr) {// 冒泡排序 的时间复杂度 O(n^2), 自己写出int temp = 0; // 临时变量boolean flag = false; // 标识变量，表示是否进行过交换for (int i = 0; i < arr.length - 1; i++) {for (int j = 0; j < arr.length - 1 - i; j++) {// 如果前面的数比后面的数大，则交换if (arr[j] > arr[j + 1]) {flag = true;temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}//System.out.println("第" + (i + 1) + "趟排序后的数组");//System.out.println(Arrays.toString(arr));if (!flag) { // 在一趟排序中，一次交换都没有发生过break;} else {flag = false; // 重置flag!!!, 进行下次判断}}
}

时间复杂度：最坏情况：O(N^2)
      最好情况：O(N)
空间复杂度：O(1)

小结冒泡排序规则

(1) 一共进行 数组的大小-1 次 的循环

(2)每一趟排序的次数在逐渐的减少

(3) 如果我们发现在某趟排序中，没有发生一次交换， 可以提前结束冒泡排序。这个就是优化 

 选择排序(SelectSort)：

选择排序（SelectSort）的基本思路：

1. 选择排序一共有 数组大小 - 1 轮排序

2. 每1轮排序，又是一个循环, 循环的规则(代码)

2.1先假定当前这个数是最小数

2.2 然后和后面的每个数进行比较，如果发现有比当前数更小的数，就重新确定最小数，并得到下标

2.3 当遍历到数组的最后时，就得到本轮最小数和下标

2.4 交换 [代码中再继续说 ]

 图解：

代码详解：

import java.util.*;
public class SelectSort {//selectsort排序的方法、public static void selectSort(int[] arr){for(int i=0;i<arr.length-1;i++){int minIdex=i;//设第一个数为最小，同时将其索引（在数组中的位置）用minIndex表示int min=arr[i];//用min记录最小的数for(int j=i+1;j<arr.length;j++){if(min>arr[j]){min=arr[j];//通过选择将最小的数选出，然后更新min和minIndexminIdex=j;}}arr[minIdex]=arr[i];//将当前位置的数和最小数交换arr[i]=min;System.out.println("这是第"+i+"次排序，结果是：");//记录排序的过程System.out.println(Arrays.toString(arr));}}
//测试排序public static void main(String[] args){Scanner sc=new Scanner(System.in);int[] arr=new int[5];System.out.println("请输入你要排序的数组：");for(int i=0;i<5;i++){arr[i]=sc.nextInt();}selectSort(arr);System.out.println("排序好后的数组是:");for(int i=0;i<5;i++){System.out.print(arr[i]+" ");}}
}

运行结果：（通过运行过程来展示排序过程）  

 时间复杂度：最坏情况：O(N^2)
      最好情况：O(N^2)
空间复杂度：O(1)

 插入排序（InsertSort）：

插入排序（InsertSort）基本思路：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素（数组的第一个元素）,.无序表中包含n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序的排序码进行比较，将它插入到有序表中的适当位置，使其成为新的有序表

图解：

代码详解：

import java.util.*;
public class InsertSort {
//InsertSort方法public static void insertSort(int[] arr){for(int i=1;i<arr.length;i++){int insertVal=arr[i];//将无序的数组的第一个元素记录，是后面要插入的数据int insertIndex=i-1;//同时有序的数组的最后一个元素的索引（元素在数组中的位置）记录while(insertIndex>=0 && insertVal<arr[insertIndex]){//判断条件，二者要同时满足arr[insertIndex+1]=arr[insertIndex];//将有序数组比insertVal小的元素后挪insertIndex--;}arr[insertIndex+1]=insertVal;//将insertVal插入合适的位置System.out.println("第"+i+"趟的排序为：");//记录排序过程System.out.println(Arrays.toString(arr));}}
//排序测试public static void main(String[] args){Scanner sc=new Scanner(System.in);int[] arr=new int[5];System.out.println("请输入要排序的数组：");for(int i=0;i< arr.length;i++){arr[i]=sc.nextInt();}insertSort(arr);System.out.println("输出排好序的数组");for(int i=0;i<arr.length;i++){System.out.print(arr[i]+" ");}}
}

 运行结果：（通过运行过程来展示排序过程）

时间复杂度：最坏情况下为O(N*N)，此时待排序列为逆序，或者说接近逆序
      最好情况下为O(N)，此时待排序列为升序，或者说接近升序。
空间复杂度：O(1)

 希尔排序(ShellSort)：

希尔排序（ShellSort）基本思路：希尔排序，先将待排序列进行预排序，使待排序列接近有序，然后再对该序列进行一次插入排序，此时插入排序的时间复杂度为O(N)

图解：

 静态图解：

 法一（交换法）代码详解：

import java.util.*;
public class ShellSort {
//ShellSort的方法public static void shellSort(int[] arr){int count=0;for(int gap= arr.length/2;gap>0;gap/=2){//将每次要排序的组别逐渐缩小for(int i=gap;i<arr.length;i++){//gap~arr.length是该组别一共要交换的次数for(int j=i-gap;j>=0;j-=gap){if(arr[j]>arr[j+gap]){//通过交换对数组进行排序int temp=arr[j];arr[j]=arr[j+gap];arr[j+gap]=temp;}}}System.out.println("第"+(++count)+"趟希尔排序是："+Arrays.toString((arr)));//记录希尔排序的过程}}//ShellSort的测试public static void main(String[] args){Scanner sc=new Scanner(System.in);int[] arr=new int[]{8,9,1,7,2,3,5,4,6,0};System.out.println("排序前"+Arrays.toString((arr)));System.out.println();shellSort(arr);System.out.println("排序后"+Arrays.toString(arr));}
}

运行结果：（通过运行过程来展示排序过程） 

 法二（移位法-->插入排序的优化）代码详解：

import java.util.*;
public class ShellSort2 {//对交换式的希尔排序进行优化->移位法public static void shellSort2(int[] arr){int count=0;// 增量gap, 并逐步的缩小增量for (int gap = arr.length / 2; gap > 0; gap /= 2) {// 从第gap个元素，逐个对其所在的组进行直接插入排序for (int i = gap; i < arr.length; i++) {int j = i;int temp = arr[j];if (arr[j] < arr[j - gap]) {while (j - gap >= 0 && temp < arr[j - gap]) {//移动arr[j] = arr[j-gap];j -= gap;}//当退出while后，就给temp找到插入的位置arr[j] = temp;}}}}//shellSort2测试public static void main(String[] args){Scanner sc=new Scanner(System.in);int[] arr=new int[]{8,9,1,7,2,3,5,4,6,0};System.out.println("排序前"+ Arrays.toString((arr)));System.out.println();shellSort2(arr);System.out.println("排序后"+Arrays.toString(arr));}
}

运行结果： 

时间复杂度平均：O(N^1.3)
空间复杂度：O(1)

快速排序（QuickSort）： 

快速排序（QuickSort）的基本思路：

1.选出一个数据（一般是最左边或是最右边的）存放在temp变量中，在该数据位置形成一个坑
2、还是定义一个l和一个R，L从左向右走，R从右向左走。（若在最左边挖坑，则需要R先走；若在最右边挖坑，则需要L先走） 

图解：

 

代码详解：

import java.util.*;
public class QuickSort {
//QuickSort方法public static void quickSort(int[] arr, int left, int right) {int l = left; //左下标int r = right; //右下标//pivot 中轴值int pivot = arr[(left + right) / 2];int temp = 0; //临时变量，作为交换时使用//while循环的目的是让比pivot 值小放到左边//比pivot 值大放到右边while (l < r) {//在pivot的左边一直找,找到大于等于pivot值,才退出while (arr[l] < pivot) {l += 1;}//在pivot的右边一直找,找到小于等于pivot值,才退出while (arr[r] > pivot) {r -= 1;}//如果l >= r说明pivot 的左右两的值，已经按照左边全部是//小于等于pivot值，右边全部是大于等于pivot值if (l >= r) {break;}//交换temp = arr[l];arr[l] = arr[r];arr[r] = temp;//如果交换完后，发现这个arr[l] == pivot值 相等 r--， 前移if (arr[l] == pivot) {r -= 1;}//如果交换完后，发现这个arr[r] == pivot值 相等 l++， 后移if (arr[r] == pivot) {l += 1;}}// 如果 l == r, 必须l++, r--, 否则为出现栈溢出if (l == r) {l += 1;r -= 1;}//向左递归if (left < r) {quickSort(arr, left, r);}//向右递归if (right > l) {quickSort(arr, l, right);}}public static void main(String[] args) {Scanner sc = new Scanner(System.in);//测试排序int[] arr = new int[5];System.out.println("请输入你要排序的数组：");for (int i = 0; i < 5; i++) {arr[i] = sc.nextInt();}quickSort(arr, 0, arr.length - 1);System.out.println("排序好后的数组是:");for (int i = 0; i < 5; i++) {System.out.print(arr[i] + " ");}}
}

运行结果：

 时间复杂度平均：O(N^LogN)
空间复杂度：O(LogN)

 归并排序（MergetSort）：

 归并排序（MergetSort）基本思路：

该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。代价是需要额外的内存空间。若将两个有序表合并成一个有序表，称为2-路归并。

 图解：

 

动态图解： 

代码详解：

import java.util.Arrays;
public class MergetSort {//分+合方法public static void mergeSort(int[] arr, int left, int right, int[] temp) {if(left < right) {int mid = (left + right) / 2; //中间索引//向左递归进行分解mergeSort(arr, left, mid, temp);//向右递归进行分解mergeSort(arr, mid + 1, right, temp);//合并merge(arr, left, mid, right, temp);}}//合并的方法/**** @param arr 排序的原始数组* @param left 左边有序序列的初始索引* @param mid 中间索引* @param right 右边索引* @param temp 做中转的数组*/public static void merge(int[] arr, int left, int mid, int right, int[] temp) {int i = left; // 初始化i, 左边有序序列的初始索引int j = mid + 1; //初始化j, 右边有序序列的初始索引int t = 0; // 指向temp数组的当前索引//(一)//先把左右两边(有序)的数据按照规则填充到temp数组//直到左右两边的有序序列，有一边处理完毕为止while (i <= mid && j <= right) {//继续//如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素//即将左边的当前元素，填充到 temp数组//然后 t++, i++if(arr[i] <= arr[j]) {temp[t] = arr[i];t += 1;i += 1;} else { //反之,将右边有序序列的当前元素，填充到temp数组temp[t] = arr[j];t += 1;j += 1;}}//(二)//把有剩余数据的一边的数据依次全部填充到tempwhile( i <= mid) { //左边的有序序列还有剩余的元素，就全部填充到temptemp[t] = arr[i];t += 1;i += 1;}while( j <= right) { //右边的有序序列还有剩余的元素，就全部填充到temptemp[t] = arr[j];t += 1;j += 1;}//(三)//将temp数组的元素拷贝到arr//注意，并不是每次都拷贝所有t = 0;int tempLeft = left; ////第一次合并 tempLeft = 0 , right = 1 //  tempLeft = 2  right = 3 // tL=0 ri=3//最后一次 tempLeft = 0  right = 7while(tempLeft <= right) {arr[tempLeft] = temp[t];t += 1;tempLeft += 1;}}public static void main(String[] args){int[] arr={56,78,13,78,33};int[] temp=new int[arr.length];System.out.println("排序前："+ Arrays.toString(arr));mergeSort(arr, 0, arr.length - 1, temp);System.out.println("排序后："+Arrays.toString(arr));}
}

运行结果：

  时间复杂度平均：O(N^LogN)
空间复杂度：O(N)

 基数排序（RadixSort）：

基数排序（RadixSort）基本思路：

基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。

图解：

代码详解：

import java.util.*;
public class RadixSort {public static void radixSort(int[] arr) {//根据前面的推导过程，我们可以得到最终的基数排序代码//1. 得到数组中最大的数的位数int max = arr[0]; //假设第一数就是最大数for (int i = 1; i < arr.length; i++) {if (arr[i] > max) {max = arr[i];}}//得到最大数是几位数int maxLength = (max + "").length();//定义一个二维数组，表示10个桶, 每个桶就是一个一维数组//说明//1. 二维数组包含10个一维数组//2. 为了防止在放入数的时候，数据溢出，则每个一维数组(桶)，大小定为arr.length//3. 名明确，基数排序是使用空间换时间的经典算法int[][] bucket = new int[10][arr.length];//为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数//可以这里理解//比如：bucketElementCounts[0] , 记录的就是  bucket[0] 桶的放入数据个数int[] bucketElementCounts = new int[10];//这里我们使用循环将代码处理for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {//(针对每个元素的对应位进行排序处理)， 第一次是个位，第二次是十位，第三次是百位..for (int j = 0; j < arr.length; j++) {//取出每个元素的对应位的值int digitOfElement = arr[j] / n % 10;//放入到对应的桶中bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];bucketElementCounts[digitOfElement]++;}//按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)int index = 0;//遍历每一桶，并将桶中是数据，放入到原数组for (int k = 0; k < bucketElementCounts.length; k++) {//如果桶中，有数据，我们才放入到原数组if (bucketElementCounts[k] != 0) {//循环该桶即第k个桶(即第k个一维数组), 放入for (int l = 0; l < bucketElementCounts[k]; l++) {//取出元素放入到arrarr[index++] = bucket[k][l];}}//第i+1轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！bucketElementCounts[k] = 0;}//System.out.println("第"+(i+1)+"轮，对个位的排序处理 arr =" + Arrays.toString(arr));}}public static void main(String[] args){Scanner sc = new Scanner(System.in);//测试排序int[] arr = new int[5];System.out.println("请输入你要排序的数组：");for (int i = 0; i < 5; i++) {arr[i] = sc.nextInt();}radixSort(arr);System.out.println("排序好后的数组是:");for (int i = 0; i < 5; i++) {System.out.print(arr[i] + " ");}}
}

 运行结果：

   时间复杂度平均：O(N*K)
空间复杂度：O(N*K)

最后，一张图概括： 

博客到这里也是结束了，制作不易，喜欢的小伙伴可以点赞加关注支持下博主，这对我真的很重要~~

 

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

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

相关文章

Java中的常用API

Java中的常用API

常用API Object类浅克隆与深克隆 ObjectsObjects中的equals 包装类StringBuilder和StringBufferStringBuilder是可变字符串对象StringBuffer线程安全案例![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/87649c20e6464113a42aee5f16f1ee22.png) StringJoiner Object…
阅读更多...
关于ZYZ旋转和XYZ旋转

关于ZYZ旋转和XYZ旋转

ZYZ旋转和XYZ旋转 概述1、XYZ旋转2、ZYZ旋转 概述 以下公式默认为右手坐标系&#xff1b;ZYZ通常可以避免死解情况&#xff0c;因此在六轴末端解算时常被用到&#xff1b;参考文章 1、XYZ旋转 XYZ旋转一般是绕固定轴旋转(外旋)&#xff0c;旋转矩阵的构成为&#xff1a;RzRy…
阅读更多...
软考 系统分析师系列知识点之需求管理（3）

软考 系统分析师系列知识点之需求管理（3）

接前一篇文章&#xff1a;软考 系统分析师系列知识点之需求管理&#xff08;2&#xff09; 所属章节&#xff1a; 第11章. 软件需求工程 第8节. 需求管理 11.8.4 需求跟踪 根据IEEE的定义&#xff0c;可跟踪性包含两个层面的含义&#xff1a;一个是开发过程的两个或多个产品之…
阅读更多...
无广告iOS获取设备UDID 简单方便快捷

无广告iOS获取设备UDID 简单方便快捷

ps&#xff1a; 为啥不用蒲公英了&#xff0c;就是因为有广告了&#xff0c;获取个UDID还安装游戏&#xff0c;真恶心?&#xff0c;所以找了新的获取UDID都方法&#xff0c;网页直接获取就可以&#xff0c;不会安装软件。 UDID 是一种 iOS 设备的特殊识别码。除序号之外&…
阅读更多...
（1）cpu0简介

（1）cpu0简介

一、cpu0介绍 cpu032位架构16位通用寄存器&#xff0c;协处理器和其他特殊寄存器 &#xff08;1&#xff09;通用寄存器 全局指针寄存器&#xff1a;"Global Pointer register"&#xff08;全局指针寄存器&#xff09;是一个在某些处理器架构中存在的专用寄存器&…
阅读更多...
单臂路由实验（思科）

单臂路由实验（思科）

一&#xff0c;实验目的 在路由器的一个接口上通过配置子接口的方式&#xff0c;实现相互隔离的不同vlan之间互通。 二&#xff0c;设备配置 Switch1 Switch>enable 全局模式 Switch#configure terminal 配置模式 Switch(config)#vlan 10 …
阅读更多...
【leetcode】20. 有效的括号

【leetcode】20. 有效的括号

有效的括号 题目链接 // 栈结构 typedef char valuetype; typedef struct {valuetype* arr;int top;int capacity; } Stack;void Init(Stack* stack);void Push(Stack* stack, valuetype value); void Pop(Stack* stack);valuetype Top(Stack* stack); int Size(Stack* stack…
阅读更多...
嵌入式中C 语言中的三块技术难点

嵌入式中C 语言中的三块技术难点

C 语言在嵌入式学习中是必备的知识&#xff0c;甚至大部分操作系统都要围绕 C 语言进行&#xff0c;而其中有三块技术难点&#xff0c;几乎是公认级别的“难啃的硬骨头”。 今天就来带你将这三块硬骨头细细拆解开来&#xff0c;一定让你看明白了。 0x01 指针 指针是公认最难理…
阅读更多...
26元/月起！腾讯云一键自动搭建4核16G幻兽帕鲁服务器

26元/月起！腾讯云一键自动搭建4核16G幻兽帕鲁服务器

腾讯云无需任何配置自动搭建幻兽帕鲁游戏联机服务器&#xff0c;游戏24小时在线&#xff0c;4核16G游戏联机服务器低至26元/月起&#xff0c;新手小白也能一键搭建属于自己的幻兽帕鲁游戏联机服务器&#xff01; 第一步&#xff1a;购买游戏联机服务器 购买入口&#xff1a;htt…
阅读更多...
Django知识随笔

Django知识随笔

目录 1.如何再ajax中传输post数据&#xff1f; 2.在form表单中使用jquery序列化&#xff0c;input框过多。 1.如何再ajax中传输post数据&#xff1f; 在ajax传递的那个网址&#xff0c;会调用你路由的视图函数&#xff0c;在视图函数上面加一句 csrf_exempt 。写上之后会有提…
阅读更多...
Android：RecyclerView跨行跨列的LayoutManager：Spannedgridlayoutmanager

Android：RecyclerView跨行跨列的LayoutManager：Spannedgridlayoutmanager

前言&#xff1a; RecyclerView可以使用GridLayoutManager实现跨行&#xff0c;但是不能跨列&#xff1b;瀑布流布局可以跨列但是又不能跨行。原生自带的各个LayoutManager中并没有可以又跨行又能跨列的。网上搜寻了一番&#xff0c;找到了一个亲测可行好用的三方库&#xff1…
阅读更多...
DL/T1578-2021电力线路多旋翼无人机巡检系

DL/T1578-2021电力线路多旋翼无人机巡检系

DL/T1578-2021电力线路多旋翼无人机巡检系 DL/T 1578—2021标准的发布和实施对于架空电力线路的巡检工作具有里程碑式的意义。它不仅填补了多旋翼无人机巡检系统在行业标准方面的空白&#xff0c;还为电力行业提供了一套完整、科学的测试和评估方法。这将有助于提高架空电力线…
阅读更多...
使用apifox创建一个Mock Server Api 接口

使用apifox创建一个Mock Server Api 接口

安装 下载 Apifox - API 文档、调试、Mock、测试一体化协作平台。拥有接口文档管理、接口调试、Mock、自动化测试等功能&#xff0c;接口开发、测试、联调效率&#xff0c;提升 10 倍。最好用的接口文档管理工具&#xff0c;接口自动化测试工具。 创建mock api项目中使用 创建项…
阅读更多...
构建LLM辅助生物威胁制造预警系统 人类越发展获取的超能力越大，破坏力越大，威胁越大。我们需要什么样的预警系统？既克服威胁又具有超能力 安全基础

构建LLM辅助生物威胁制造预警系统 人类越发展获取的超能力越大，破坏力越大，威胁越大。我们需要什么样的预警系统？既克服威胁又具有超能力 安全基础

https://openai.com/research/building-an-early-warning-system-for-llm-aided-biological-threat-creation 人类越发展获取的超能力越大&#xff0c;破坏力就越大&#xff0c;威胁越大。 人工智能就是为了赋予人人都能有超能力&#xff0c;而一旦被恶意或无意使用又威胁到人…
阅读更多...
生产问题排查系列——未知404状态接口请求

生产问题排查系列——未知404状态接口请求

引言 我们的产品主打金融服务领域&#xff0c;以B端客户为我们的核心合作伙伴&#xff0c;然而&#xff0c;我们的服务最终将惠及C端消费者。在技术实现上&#xff0c;我们采用了公司自主研发的微服务框架&#xff0c;该框架基于SpringBoot&#xff0c;旨在提供高效、可靠的服…
阅读更多...
vtkNIFTIImageReader读写方位以及原点信息

vtkNIFTIImageReader读写方位以及原点信息

使用vtkNIFTIImageReader读取体数据为vtkImageData时只会携带spacing信息&#xff0c;方向和原点信息不会写入&#xff0c;需要获取QFormMatrix进行解析。 1、方向及原点读取 vtkSmartPointer<vtkNIFTIImageReader> niiReader vtkSmartPointer<vtkNIFTIImageReader&…
阅读更多...
数据结构—基础知识：哈夫曼树

数据结构—基础知识：哈夫曼树

数据结构—基础知识&#xff1a;哈夫曼树 哈夫曼树的基本概念 哈夫曼&#xff08;Huffman&#xff09;树又称最优树&#xff0c;是一类带权路径长度最短的树&#xff0c;在实际中有广泛的用途。哈夫曼树的定义&#xff0c;涉及路径、路径长度、权等概念&#xff0c;下面先给出…
阅读更多...
Vue学习之使用HBuilderX创建并使用vue3.0项目

Vue学习之使用HBuilderX创建并使用vue3.0项目

Vue学习之使用HBuilderX创建并使用vue3.0项目 下文将简述如何使用HBuilderX创建并使用vue3.0项目&#xff0c;包含项目创建、目录介绍、如何引用组件、首页自定义设置。 1、创建vue3.0项目 具体操作之前章节已经阐述过不在冗余介绍&#xff0c;创建时选择vue3项目即可。vue2…
阅读更多...
【C++】C++入门 — 指针空值nullptr

【C++】C++入门 — 指针空值nullptr

C入门 指针空值 指针空值 在良好的C/C编程习惯中&#xff0c;声明一个变量时最好给该变量一个合适的初始值&#xff0c;否则可能会出现 不可预料的错误&#xff0c;比如未初始化的指针。如果一个指针没有合法的指向&#xff0c;我们基本都是按照如下 方式对其进行初始化: voi…
阅读更多...
数据解构+算法（第07篇）：动态编程！黄袍加身！

数据解构+算法（第07篇）：动态编程！黄袍加身！

作者简介&#xff1a;大家好&#xff0c;我是smart哥&#xff0c;前中兴通讯、美团架构师&#xff0c;现某互联网公司CTO 联系qq&#xff1a;184480602&#xff0c;加我进群&#xff0c;大家一起学习&#xff0c;一起进步&#xff0c;一起对抗互联网寒冬 学习必须往深处挖&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023