六大排序算法:插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序

本章讲述数据结构中的六大排序算法
欢迎大佬们踊跃讨论,感谢大家支持!
我的博客主页链接
在这里插入图片描述

六大排序算法

  • 一.插入排序
      • 1.1 直接插入排序
      • 1.2 希尔排序
  • 二.选择排序
      • 2.1 单向选择排序
      • 2.2双向选择排序
      • 2.3 堆排序
  • 三.交换排序
      • 3.1 冒泡排序
      • 3.2 快速排序
        • 3.2.1 Hoare排序
        • 3.2.2 挖坑法
        • 3.2.3 前后指针法
        • 3.4 非递归快速排序
  • 四.归并排序
    • 4.1 递归归并排序
    • 4.2非递归归并排序
  • 五.计数排序
  • 六.测试运行时间代码

一.插入排序

1.1 直接插入排序

1.已知第一个元素如果不包含其他元素,没有元素可以比较,为有序。
2.我们可以直接从第二个元素i开始,创建一个对象tmp来接下标元素,如果比前一个元素小,前一个元素往后移动,tmp插入i-1下标
3.当元素大于或者等于时,则tmp直接放在i位置即可。
在这里插入图片描述

  public static void insertSort(int[] array){for(int i=1;i<array.length;i++){//由数组1下标开始进行比较int tmp=array[i];int j=i-1;for(;j>=0;j--){if(tmp<array[j]){array[j+1]=array[j];//将j放入j+1位置}else{//进入else则为有序,break跳出嵌套循环break;}}//当嵌套的for循环一直在比较最小值tmp,知道为-1跳出循环,这里需要j+1//当大于时候,因为i-1赋值给j,break跳出后j需要+1下标值得到tmparray[j+1]=tmp;}}

时间复杂度:最坏情况时间复杂度为O(N*N)
最好情况时间复杂度为O(N)
空间复杂度O(1)
稳定排序


1.2 希尔排序

希尔排序又称缩小增量法。
希尔排序的思想,定义一个整数,将待排序数组元素长度分成多个组,每一个组进行插入排序,重复上述分组,此时为预排序。当到达1时,将所有记录好的元素在一组中进行排序。
每一次分组排序后都变为有序,每组数据由少变多,越来越有序。
在这里插入图片描述
划分为n/2组进行比较,根据n/2的距离来划分每一组的数量。
在这里插入图片描述

   public static void shellSort(int[] array){int gap=array.length;while(gap>1){gap/=2;//将数组/2,有多组变少组直到为1shell(array,gap);}}public static void shell(int[] arr,int gap){//从gap开始遍历for(int i=gap;i<arr.length;i++){//获取gap下标的值int tmp=arr[i];求i-gap个差距得到j值int j=i-gap;for(;j>=0;j-=gap){if(tmp<arr[j]){arr[j+gap]=arr[j];}else{break;}}arr[j+gap]=tmp;}}

时间复杂度O(N^1.25)
空间复杂度O(1)


二.选择排序

2.1 单向选择排序

单向选择排序通过定义minIndex值来获取最小的元素下标,然后与0下标进行交换
在这里插入图片描述

   public static void selectSort2(int[] array){for(int i=0;i<array.length;i++){int minIndex=i;for(int j=i+1;j<array.length;j++){if(array[j]<array[minIndex]){minIndex=j;}}swap(array,minIndex,i);}}

2.2双向选择排序

双向选择排序是我们通过定义起始位置和终点位置的下标作为条件,通过初始位置筛选最大值和最小值的下标,将最大值下标与尾部交换,最小值下标与初始位置交换,然后继续重复上述,知道筛选完成。
在这里插入图片描述
这里如果max的最大值为0下标的时候,max已经被 minIndex交换,maxIndex等于minIndex获取最大元素的下标值即可。

在这里插入图片描述

 public static void selectSort(int[] array){//起始位置和末尾的下标值int left=0;int right=array.length-1;while(left<right){//都从0下标开始比较int maxIndex=left;int minIndex=left;for(int i=left+1;i<=right;i++){if(array[i]<array[minIndex]) minIndex=i;if(array[i]>array[maxIndex]) maxIndex=i;}swap(array,left,minIndex);//如果0下标就是maxIndex的最大值,minIndex的位置就是maxIndex的最大值if(maxIndex==left)maxIndex=minIndex;swap(array,right,maxIndex);left++;right--;}}

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


2.3 堆排序

堆序详情堆排序

 //创建二叉堆public static void createHeap(int[] array){for(int parent=(array.length-1-1)/2;parent>=0;parent--){siftDown(array,parent,array.length);}}private static void siftDown(int[] array,int parent,int size) {int child=2*parent+1;while(child<size){if(child+1<size&&array[child]<array[child+1]){//child是左右孩子的最大值child=child+1;}if(array[child]>array[parent]){//交换孩子与父亲swap(array,child,parent);//调整父亲节点和孩子节点parent=child;child=(2*parent)+1;}else{break;}}}//根据创建好的大跟堆,通过最后一个下标与0下标交换后缩小堆的范围,直到称为有序数组public static void heapSort(int[] array){createHeap(array);int end=array.length-1;while(end>0){swap(array,0,end);siftDown(array,0,end);end--;}}

时间复杂度O(N*logN)
空间复杂度O(1)


三.交换排序

3.1 冒泡排序

冒泡排序是一种较为简单的排序算法,它循环需要排序的元素,依次比较相邻的两个元素,如果顺序错误就进行交换,直至没有元素交换,完成排序,若对数组n个元素进行比较,则需要比较n-1次,最后一个元素已经被前n-1个元素排序好。
排序一次将len-1最大值放到最后,直到有序
本代码中的flag来记录是否有序,如果有序,则直接跳出循环。
在这里插入图片描述

 public static void bubbleSort(int[] array){for(int i=0;i<array.length-1;i++){boolean flag=false;//这里标记一下,每一趟中,给flag置为false,当每趟为有序后,则不进入if语句直接停止循环for(int j=0;j<array.length-1-i;j++){if(array[j]>array[j+1]){swap(array,j,j+1);flag=true;}}if(!flag){break;}}}

时间复杂度:最好情况下:O(n)
最坏情况下:O(n^2)
空间复杂度:O(1)
稳定排序


3.2 快速排序

3.2.1 Hoare排序

1.首先设定一个分界值,通过该分界值将数组分成左右两部分。
2、将大于或等于分界值的数据集中到数组右边,小于分界值的数据集中到数组的左边。此时,左边部分中各元素都小于分界值,而右边部分中各元素都大于或等于分界值。
3、然后,左边和右边的数据可以独立排序。对于左侧的数组数据,又可以取一个分界值,将该部分数据分成左右两部分,同样在左边放置较小值,右边放置较大值。右侧的数组数据也可以做类似处理。
4、重复上述过程,可以看出,这是一个递归定义。通过递归将左侧部分排好序后,再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后,整个数组的排序也就完成了。

在这里插入图片描述
在这里插入图片描述

这里定义一个left为左,right为右,将任意左右位置两边定义一个基准值,根据基准值的大小,直到left为大于基准值数,right为小于基准值数停下,若定义左边为基准值则右边先走,同理右边为基准值左边先走

 //快速排序public static void quickSort(int[] array){//记录左起始位置和右边的结束位置进行递归quick(array,0,array.length-1);}
public static void inSert(int[] array,int left,int right){for(int i=left+1;i<=right;i++){int tmp=array[i];int j=i-1;for(;j>=left;j--){if(array[j]>tmp){array[j+1]=array[j];}else {break;}}array[j+1]=tmp;}}private static int middleNum(int[] array, int left, int right) {int mid=(left+right)/2;if(array[left]>array[right]){//说明left大if(array[right]>array[mid]){return right;} else if (array[left]<array[mid]) {return left;}else{return mid;}}else{//right大判断中间值if(array[left]>array[mid]){return left;}else if(array[right]<array[mid]){return right;}else{return mid;}}}private static void quick(int[] array, int left, int right) {if(left>=right)return ;//说明两个相遇或者走出范围//当长度少时直接插入排序if(right-left+1<=10){inSert(array,left,right);return ;}int index = middleNum(array,left,right);System.out.println("index下标值:"+index);//用来交换left和right范围内元素且最终将首位元素与相遇值交换swap(array,left,index);int pos=partitionPointer(array,left,right);//递归quick(array,left,pos-1);quick(array,pos+1,right);}private static int partitionHoare(int[] array, int left, int right) {int record=left;//记录left最后交换int tmp=array[left];//比较大小while(left<right){while(left<right&&array[right]>=tmp){//右边找到小于tmpright--;}while(left<right&&array[left]<=tmp){//左边找到大于tmpleft++;}swap(array,left,right);}//这里left与right相遇swap(array,record,left);return left;}

时间复杂度:最坏情况下N*(logN)
最好情况下:O(N^2) 有序或者逆序情况下
空间复杂度:最好情况下O(logN)
最坏情况下:O(N) 有序或者逆序情况下
数据多时因递归可能容易栈溢出


3.2.2 挖坑法

1.由左或者右选出第一个坑位记录元素值,放入key中,创建left和right对数组遍历,当选左坑右走,右坑左走,直到right和left相遇后将记录的坑位元素值放入即可。
在这里插入图片描述

 public static void quickSort(int[] array){//记录左起始位置和右边的结束位置进行递归quick(array,0,array.length-1);}public static void inSert(int[] array,int left,int right){for(int i=left+1;i<=right;i++){int tmp=array[i];int j=i-1;for(;j>=left;j--){if(array[j]>tmp){array[j+1]=array[j];}else {break;}}array[j+1]=tmp;}}private static int middleNum(int[] array, int left, int right) {int mid=(left+right)/2;if(array[left]>array[right]){//说明left大if(array[right]>array[mid]){return right;} else if (array[left]<array[mid]) {return left;}else{return mid;}}else{//right大判断中间值if(array[left]>array[mid]){return left;}else if(array[right]<array[mid]){return right;}else{return mid;}}}private static void quick(int[] array, int left, int right) {if(left>=right)return ;//说明两个相遇或者走出范围if(right-left+1<=10){inSert(array,left,right);return ;}int index = middleNum(array,left,right);System.out.println("index下标值:"+index);//用来交换left和right范围内元素且最终将首位元素与相遇值交换swap(array,left,index);int pos=partitionPointer(array,left,right);//递归quick(array,left,pos-1);quick(array,pos+1,right);}private static int partitionPit(int[] array, int left, int right) {int record=array[left];//记录起始坑位while(left<right){while(left<right&&array[right]>=record){//右边找到小于tmpright--;}//说明找到小于tmp的值array[left]=array[right];while(left<right&&array[left]<=record){//左边找到大于tmpleft++;}//说明找到大于tmp的值array[right]=array[left];}//这里left与right相遇后将记录的首个坑填入array[left]=record;return left;}

3.2.3 前后指针法

cur指向起始位置+1,pre是cur的前一位
判断条件:如果cur找到基准值(最初位置key为5),前一项的条件满足后prev向后走不为cur(为cur则不交换),直到prev在前cur在后且cur<基准值
cur如果大于基准值,直到cur找到小于基准值的数或者走完,直到递归调整为升序。
在这里插入图片描述

   public static void quickSort(int[] array){//记录左起始位置和右边的结束位置进行递归quick(array,0,array.length-1);}public static void inSert(int[] array,int left,int right){for(int i=left+1;i<=right;i++){int tmp=array[i];int j=i-1;for(;j>=left;j--){if(array[j]>tmp){array[j+1]=array[j];}else {break;}}array[j+1]=tmp;}}private static int middleNum(int[] array, int left, int right) {int mid=(left+right)/2;if(array[left]>array[right]){//说明left大if(array[right]>array[mid]){return right;} else if (array[left]<array[mid]) {return left;}else{return mid;}}else{//right大判断中间值if(array[left]>array[mid]){return left;}else if(array[right]<array[mid]){return right;}else{return mid;}}}private static void quick(int[] array, int left, int right) {if(left>=right)return ;//说明两个相遇或者走出范围if(right-left+1<=10){inSert(array,left,right);return ;}int index = middleNum(array,left,right);System.out.println("index下标值:"+index);//用来交换left和right范围内元素且最终将首位元素与相遇值交换swap(array,left,index);int pos=partitionPointer(array,left,right);//递归quick(array,left,pos-1);quick(array,pos+1,right);}private static int partitionPointer(int[] array, int left, int right) {//记录cur的前一项int Prev=left;int cur=left+1;while(cur<=right){//cur与起始位置比较只有小于才能进行交换且prev不为curif(array[cur]<array[left]&&array[++Prev]!=array[cur]){swap(array,cur,Prev);}cur++;}//交换最后记录的cur的值swap(array,left,Prev);return Prev;}

3.4 非递归快速排序

这里非递归排序的情况下,因为每次最左边的数我们需要申请一个栈来记录其区间值,出栈由区间值一步步缩小取值的范围并进行交换,重复上述即可。

 public static void quickNor(int[] array){quickSortNor(array,0,array.length-1);}private static void quickSortNor(int[] array, int left, int right) {Stack<Integer> stack=new Stack<>();int pivot=partitionHoare(array,left,right);if(pivot>left+1){stack.push(left);stack.push(pivot-1);}if(pivot+1<right){stack.push(pivot+1);stack.push(right);}while(!stack.isEmpty()){right = stack.pop();left = stack.pop();pivot=partitionHoare(array,left,right);if(pivot>left+1){stack.push(left);stack.push(pivot-1);}if(pivot+1<right){stack.push(pivot+1);stack.push(right);}}

四.归并排序

4.1 递归归并排序

定义一个分界线mid来获取其中间值,递归左边和右边,每次进入方法进行排序
将左起始到中间值与中间值到右侧比较,创建一个数组来记录,排序后放到数组中,最后让原数组接收。

    public static void mergeSort(int[] array){mergeSortM(array,0,array.length-1);}private static void mergeSortM(int[] array, int left, int right) {//知道left和right相遇返回if(left>=right)return ;int mid=(left+right)/2;//以中间值作为分区,递归左边和右边mergeSortM(array,left,mid);mergeSortM(array,mid+1,right);//每次递归传入后进行排序merge(array,left,mid,right);}private static void merge(int[] array, int left, int mid, int right) {int[] tmpArr=new int[right-left+1];//创建一个数组接收每一次递归的数组int k=0;//记录左边的起始位置与右边起始位置int s1=left;int s2=mid+1;while(s1<= mid &&s2<= right){if(array[s1]<=array[s2]){tmpArr[k++]=array[s1++];}else{tmpArr[k++]=array[s2++];}}while(s1<= mid){tmpArr[k++]=array[s1++];}while(s2<= right){tmpArr[k++]=array[s2++];}for(int i=0;i<tmpArr.length;i++){//这里的left跟随着mid改变,当递归右侧时,left为mid+1array[i+left]=tmpArr[i];}}
}

时间复杂度:O(N*logN)
空间复杂度:O(logN)
稳定排序


4.2非递归归并排序

以每组两个形式分开进行排序,在以每组四个形式排序持续,直到为有序数组。
定义一个gap来每组存储几个数据,通过i下标遍历将每组进行排序,而i下标遍历是以组的形式遍历的,这里直接i+gap*2。
这里left下标就是i,而mid下标是以gap第几组+left-1获取mid值,right值为mid+gap获取最后下标,这里注意可能mid和right会超出范围,如果超出范围,一定是最后一个下标
小·

  private static void merge(int[] array, int left, int mid, int right) {int[] tmpArr=new int[right-left+1];//创建一个数组接收每一次递归的数组int k=0;//记录左边的起始位置与右边起始位置int s1=left;int s2=mid+1;while(s1<= mid &&s2<= right){if(array[s1]<=array[s2]){tmpArr[k++]=array[s1++];}else{tmpArr[k++]=array[s2++];}}while(s1<= mid){tmpArr[k++]=array[s1++];}while(s2<= right){tmpArr[k++]=array[s2++];}for(int i=0;i<tmpArr.length;i++){array[i+left]=tmpArr[i];}}public static void mergeNor(int[] array){int gap=1;//每组共有几个数据while(gap<array.length){for(int i=0;i<array.length;i=i+gap*2){int left=i;int mid=left+gap-1;int right=mid+gap;if(mid>=array.length)mid=array.length-1;if(right>=array.length){right=array.length-1;}merge(array,left,mid,right);}gap*=2;}}

五.计数排序

计数排序是不需要对两个数值进行比较的排序,他应用于一个数组中指定的区间范围内。
取数组中最大值与最小值
最大值与最小值的差+1作为新的数组长度len不是指定范围内的话,会浪费很多空间
创建一个临时数组大小为len来进行计数,将array[i]下标-最小值的差放入临时数组中,循环直到结束
临时数组中的计数i需要大于0才证明有计数最后将临时数组给到array数组中即可,之需要将i差值+最小值得到array下标的值即可。
在这里插入图片描述

private static void sortCount(int[] array) {int maxVal=array[0];int minVal=array[0];for (int i = 0; i < array.length; i++) {if(array[i]>maxVal)maxVal=array[i];if(array[i]<minVal)minVal=array[i];}int len=maxVal-minVal+1;int[] count=new int[len];for(int i=0;i<array.length;i++){count[array[i]-minVal]++;}int index=0;for(int i=0;i<count.length;i++){while(count[i]>0){array[index]=i+minVal;index++;count[i]--;}}}

六.测试运行时间代码

  // 有序public static void order(int[] arr){for(int i=0;i<arr.length;i++){arr[i]=i;}}//逆序public static void reverse(int[] arr){for(int i=0;i<arr.length;i++){arr[i]= arr.length-i;}}//无序public static void disorder(int[] arr){Random random=new Random();for(int i=0;i<arr.length;i++){arr[i]= random.nextInt(100);}}//测试public static void testSort1(int[] arr){int[] tmpArray= Arrays.copyOf(arr,arr.length);long startTime=System.currentTimeMillis();//开始结束记录Sort.shellSort(tmpArray);long endTime=System.currentTimeMillis();System.out.println("希尔排序时间:"+(endTime-startTime));}public static void testSort2(int[] arr){int[] tmpArray= Arrays.copyOf(arr,arr.length);long startTime=System.currentTimeMillis();//开始结束记录Sort.inSert(tmpArray);long endTime=System.currentTimeMillis();System.out.println("插入排序时间:"+(endTime-startTime));}public static void testSort3(int[] arr){int[] tmpArray= Arrays.copyOf(arr,arr.length);long startTime=System.currentTimeMillis();//开始结束记录Sort.selectSort2(tmpArray);long endTime=System.currentTimeMillis();System.out.println("双向选择排序时间:"+(endTime-startTime));}public static void testSort4(int[] arr){int[] tmpArray= Arrays.copyOf(arr,arr.length);long startTime=System.currentTimeMillis();//开始结束记录Sort.bubbleSort(tmpArray);long endTime=System.currentTimeMillis();System.out.println("冒泡排序时间:"+(endTime-startTime));}public static void testSort5(int[] arr){int[] tmpArray= Arrays.copyOf(arr,arr.length);long startTime=System.currentTimeMillis();//开始结束记录Sort.heapSort(tmpArray);long endTime=System.currentTimeMillis();System.out.println("堆排序时间:"+(endTime-startTime));}public static void testSort6(int[] arr){int[] tmpArray= Arrays.copyOf(arr,arr.length);long startTime=System.currentTimeMillis();//开始结束记录Sort.quickSort(tmpArray);long endTime=System.currentTimeMillis();System.out.println("Hoare快速排序时间:"+(endTime-startTime));}public static void testSort7(int[] arr){int[] tmpArray= Arrays.copyOf(arr,arr.length);long startTime=System.currentTimeMillis();//开始结束记录Sort.quickSort(tmpArray);long endTime=System.currentTimeMillis();System.out.println("挖坑法快速排序时间:"+(endTime-startTime));}public static void testSort8(int[] arr){int[] tmpArray= Arrays.copyOf(arr,arr.length);long startTime=System.currentTimeMillis();//开始结束记录Sort.quickSort(tmpArray);long endTime=System.currentTimeMillis();System.out.println("前后指针法快速排序时间:"+(endTime-startTime));}

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

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

相关文章

el-table手动触发懒加载

二次修改了一下&#xff0c;确保点击某一单元格格元素触发 // 隐藏懒加载箭头后手动触发懒加载 expandRows(scope){scope.row.isExpanded !scope.row.isExpanded // 切换展开状态let isExpanded scope.row.isExpandedconst { table: { toggleRowExpansion, store }} this.$r…

【MySQL】数据库 Navicat 可视化工具与 MySQL 命令行基本操作

&#x1f4af; 欢迎光临清流君的博客小天地&#xff0c;这里是我分享技术与心得的温馨角落 &#x1f4af; &#x1f525; 个人主页:【清流君】&#x1f525; &#x1f4da; 系列专栏: 运动控制 | 决策规划 | 机器人数值优化 &#x1f4da; &#x1f31f;始终保持好奇心&…

threejs相机辅助对象cameraHelper

为指定相机创建一个辅助对象&#xff0c;显示这个相机的视锥。 想要在场景里面显示相机的视锥&#xff0c;需要创建两个相机。 举个例子&#xff0c;场景中有个相机A&#xff0c;想要显示相机A的视锥&#xff0c;那么需要一个相机B&#xff0c;把B放在A的后面&#xff0c;两个…

反向代理-缓存篇

文章目录 强缓存一、Expires(http1.0 规范)二、cache-control(http1.1 出现的 header 信息)Cache-Control 的常用选项Cache-Control 常用选项的选择三、弊端协商缓存一、ETag二、If-None-Match三、Last-modified四、If-Modified-Since浏览器的三种刷新方式静态资源部署策略…

深度学习小麦头检测-基于Faster-RCNN的小麦头检测——附项目源码

比赛描述 为了获得有关全世界麦田的大量准确数据,植物科学家使用“小麦头”(包含谷物的植物上的穗)的图像检测。这些图像用于估计不同品种的小麦头的密度和大小。但是,在室外野外图像中进行准确的小麦头检测可能在视觉上具有挑战性。密集的小麦植株经常重叠,并且风会使照片…

健康管理系统(Koa+Vue3)

系统界面(源码末尾获取) 系统技术 Vue3 Koa Nodejs Html Css Js ....... 系统介绍 系统比较简单,轻轻松松面对结业课堂作业.采用的是基于nodejs开发的Koa框架作为后端,采用Vue框架作为前端,完成快速开发和界面展示. 系统获取 啊啊啊宝/KoaVue3https://gitee.com/ah-ah-b…

数据清洗代码:缺失值,异常值,离群值Matlab处理

目录 基本介绍程序设计参考资料基本介绍 一、过程概述 本过程适用于处理SCADA系统采集到的数据,以及具有类似需求的数据集。处理步骤包括缺失值处理、异常值处理和离群值处理,旨在提升数据质量,增强数据的相关性,同时保持数据的原始特征和随机性。 二、缺失值处理 对于SC…

Leetcode 每日一题 202.快乐数

目录 题意 算法思路 过题图片 算法实现 代码解析 复杂度分析 题目链接 结论 题意 判断正整数 n 是不是快乐数。 快乐数定义&#xff1a; &#xff08;1&#xff09;每次将正整数替换为它每个位置上的数字的平方和。 &#xff08;2&#xff09;重复这个过程直到这个数…

【鸿蒙生态崛起】开发者如何把握机遇,应对挑战,打造卓越应用体验?

文章目录 每日一句正能量前言鸿蒙简析鸿蒙生态的认知和了解鸿蒙生态的崛起分析 鸿蒙生态下开发时遇到的挑战开发工具不完善技术难度生态竞争抓住机遇、应对挑战 鸿蒙生态未来的发展趋势1. 全场景智慧生活的推动者2. 技术创新的引领者3. 开放合作的倡导者对鸿蒙生态和开发者的建…

Nignx部署Java服务测试使用的Spring Boot项目Demo

天行健&#xff0c;君子以自强不息&#xff1b;地势坤&#xff0c;君子以厚德载物。 每个人都有惰性&#xff0c;但不断学习是好好生活的根本&#xff0c;共勉&#xff01; 文章均为学习整理笔记&#xff0c;分享记录为主&#xff0c;如有错误请指正&#xff0c;共同学习进步。…

文本域设置高度 加上文字限制并show出来:

文本域设置高度 :rows"4" 加上文字限制并show出来&#xff1a; maxlength"30" show-word-limit 效果: <el-form-item label"产品备注" prop"remark"><el-input v-model"form.remark" type"textarea"…

区块链软件系统海外宣发:全球化市场中的策略与实施

随着区块链技术的快速发展&#xff0c;越来越多的区块链软件系统进入全球市场&#xff0c;涉及加密货币、智能合约、去中心化金融&#xff08;DeFi&#xff09;、供应链管理等多个行业应用。为了在激烈的竞争中脱颖而出&#xff0c;区块链软件系统不仅需要具备卓越的技术能力&a…

springboot413福泰轴承股份有限公司进销存系统(论文+源码)_kaic

摘 要 使用旧方法对福泰轴承股份有限公司进销存系统的信息进行系统化管理已经不再让人们信赖了&#xff0c;把现在的网络信息技术运用在福泰轴承股份有限公司进销存系统的管理上面可以解决许多信息管理上面的难题&#xff0c;比如处理数据时间很长&#xff0c;数据存在错误不…

qiankun学习记录

什么是微前端 微前端是指存在于浏览器中的微服务&#xff0c;其借鉴了微服务的架构理念&#xff0c;将微服务的概念扩展到了前端。 如果对微服务的概念比较陌生的话&#xff0c;可以简单的理解为微前端就是将一个大型的前端应用拆分成多个模块&#xff0c;每个微前端模块可以…

配置中心 选型 : Apollo Vs. Nacos Vs. spring cloud config

为什么我们需要一个微服务配置中心&#xff1f; 首先&#xff0c;我们可以想象下&#xff0c;如果没有配置中心&#xff0c;我们的项目可能是这样的&#xff1a;不同环境的配置文件都放在项目里面&#xff0c;部署时可以通过启动参数来指定使用哪个环境的配置。 这种方式有两…

HarmonyOS(65) ArkUI FrameNode详解

Node 1、Node简介2、FrameNode2.1、创建和删除节点2.2、对FrameNode的增删改2.3、 FramNode的查询功能3、demo源码4、总结5、参考资料1、Node简介 在HarmonyOS(63) ArkUI 自定义占位组件NodeContainer介绍了自定义节点复用的原理(阅读本本篇博文之前,建议先读读这个),在No…

详解RabbitMQ在Ubuntu上的安装

​​​​​​​ 目录 Ubuntu 环境安装 安装Erlang 查看Erlang版本 退出命令 ​编辑安装RabbitMQ 确认安装结果 安装RabbitMQ管理界面 启动服务 查看服务状态 通过IP:port访问 添加管理员用户 给用户添加权限 再次访问 Ubuntu 环境安装 安装Erlang RabbitMq需要…

vue图片之放大、缩小、1:1、刷新、左切换、全屏、右切换、左旋咋、右旋转、x轴翻转、y轴翻转

先上效果&#xff0c;代码在下面 <template><!-- 图片列表 --><div class"image-list"><img:src"imageSrc"v-for"(imageSrc, index) in images":key"index"click"openImage(index)"error"handleI…

【计算机网络】实验12:网际控制报文协议ICMP的应用

实验12 网际控制报文协议ICMP的应用 一、实验目的 验证ping命令和tracert命令的工作原理。 二、实验环境 Cisco Packet Tracer模拟器 三、实验过程 1.构建网络拓扑并进行信息标注&#xff0c;将所需要配置的IP地址写在对应的主机或者路由器旁边&#xff0c;如图1所示。 图…

迭代器模式的理解和实践

引言 在软件开发中&#xff0c;我们经常需要遍历容器对象&#xff08;如数组、列表、集合等&#xff09;中的元素。如果每个容器对象都实现自己的遍历算法&#xff0c;那么代码将会变得冗余且难以维护。为了解决这个问题&#xff0c;迭代器模式应运而生。迭代器模式是一种行为型…