【数据结构和算法】--- 基于c语言排序算法的实现(2)

目录

  • 一、交换排序
    • 1.1 冒泡排序
    • 1.2 快速排序
      • 1.2.1 hoare法
      • 1.2.2 挖坑法
      • 1.2.3 前后指针法
    • 1.3 快速排序优化
      • 1.3.1 三数取中法选key
      • 1.3.2 递归到小的子区间使用插入排序
    • 1.4 快排非递归版
  • 二、归并排序
    • 2.1 归并排序
      • 2.1.1 递归版
      • 2.1.2 非递归版

一、交换排序

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

1.1 冒泡排序

说起冒泡排序,这也算是在我们学习编程时遇到的第一个排序算法,总体逻辑就是从待排序数组第一个一直向后遍历,遇到比自己大的就记录该值,遇到比自己小的就交换,直到到达待排序数组结尾,此时待排序数组长度--,依此逻辑每次都能将最大值移动到最后。直到待排序数组长度为0,此时数组已有序。

冒泡排序动态演示:

在这里插入图片描述

在实现代码时,还可以增加一个变量bool exchange = true如果一趟遍历下来,没有任何数据进行交换,则exchange不变,代表此时数组已有序,那么便直接结束排序(if(exchange == true) break;);如果发生数据交换,则改变exchange值为false,那么排序任然继续下一趟。 代码如下:

//冒泡排序
void BubbleSort(int* a, int n)
{//排序趟数for(int i = 0; i < n - 1; ++i){bool exchange = true;//每趟需要排的元素for(int j = 0; j < n - 1 - i; ++j){//左大于右就交换if(a[j] > a[j + 1]){Swap(&a[j], &a[j + 1])exchange = false;}}if(exchange == true)break;}
}

冒泡排序的特性总结:

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

1.2 快速排序

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

那么具体是如何实现的呢?可以参考如下过程:
在这里插入图片描述
事实上整体逻辑就是二叉树的前序遍历,即先处理当前数组,取基准值,以基准值为标准划分左右两部分,然后递归基准值左部分([begin, div - 1]),最后在递归基准值右部分([div + 1, end])。begin >= end作为结束条件,说明当前已经递归到的部分的数据个数<= 1return回到上层递归。

整个递归逻辑的主体部分为partion()函数,用来划分基准值左右两部分,并返回当前基准值的下标。 可以使用三种方法来实现partion()函数,即初版hoare法,挖坑法,前后指针法,后两者是对hoare法的改进,下面将逐一介绍!

递归框架:

// 假设按照升序对a数组中[bedin, end]区间中的元素进行排序
void QuickSort(int* a, int begin, int end)
{if(begin >= end)return;// 按照基准值对a数组的 [begin, end]区间中的元素进行划分int div = partion(a, begin, end);// 划分成功后以div为边界形成了左右两部分 [begin, div - 1] 和 [div + 1, end]// 递归排[begin, div - 1]QuickSort(a, begin, div - 1);// 递归排[div + 1, end]QuickSort(a, div + 1, end);
}

上述为快速排序递归实现的主框架,发现与二叉树前序遍历规则非常像,我们可以参照二叉树前序遍历(如有疑问请参考:【数据结构和算法】— 二叉树(3)–二叉树链式结构的实现(1))规则即可快速写出来,后序只需分析如何按照基准值来对区间中数据进行划分的方式即可。

将区间按照基准值划分为左右两半部分的常见方式有:

1.2.1 hoare法

hoare法 动态演示:
在这里插入图片描述
hoare法主要思想:定义两个变量分别对应待排序数组首元素下标int left = begin,待排序数组尾元素下标int right = end右边先向左找小于a[keyi]的值,找到后,左边在向右找大于a[keyi]的值,然后交换两数Swap(&a[left], &a[right])。需要注意的是,在寻找过程中要保证left < right最后直到left == right,将基准值和相遇点的值交换Swap(&a[keyi], &a[left]),并返回基准值下标return keyi

hoare法代码:

//hoare法
int partion(int* a, int begin, int end)
{int left = begin, right = end;//设基准值为首元素,keyi记录下标int keyi = begin;while(left < right){//右向左 找小于a[keyi]的值while(left < right && a[keyi] <= a[right]--right;//左向右 找大于a[keyi]的值while(left < right && a[keyi] >= a[left]++left;//找完一次便交换,Swap(&a[left], &a[right]);}//left 和 right 相遇交换基准值和 < a[keyi] 的值(即a[left])Swap(&a[left], &a[keyi]);return left;
}

相信看完上面上面代码和演示,会有这么一个问题:为什么相遇的位置比a[keyi]要小呢?

因为左边做keyi,右边right先走:

  • 情况1:right先遇到left。此时right没有找到比a[keyi]小的,一直走,直到遇到left,相遇位置是a[left],一定比a[keyi]小;
  • 情况2:left先遇到right。因为是right先走,找到小于a[keyi]的元素便会停下,接着left找大,没有找到,遇到了right停下来了,相遇点是right,比a[keyi]要小。

当然如果右边做基准值,那么必须要左边left先走,才能确保相遇点都大于a[keyi]

1.2.2 挖坑法

挖坑法 动态演示:
在这里插入图片描述
挖坑法主要思想:先取出基准值,并将其赋值给key ,此时这个位置就空出来了,称之为坑位,holei来记录坑位的下标。 紧接着右边向左找小(即小于key的元素),若找到就将该元素填入坑位中a[holei] = a[end],并改变坑位为替换元素的下标holei = end,然后左边向右找大(即大于key的元素),同样填入坑位,并更新坑位。依次循环,直到左右相遇begin == end,这时将基准值填入坑中(a[holei] = key),并返回坑位return holei;

挖坑法代码:

//挖坑法
int partion(int* a, int begin, int end)
{//基准值记录int key = a[begin];//坑位记录int holei = begin;while(begin < end){//右边找小,填左坑,更新坑位while(begin < end && a[end] >= key)--end;a[holei] = a[end];holei = end;//左边找小,填右坑,更新坑位while(begin < end && a[begin] <= key)++begin;a[holei] = a[begin];holei = begin;}//基准值填入坑位a[holei] = key;return holei;
}

1.2.3 前后指针法

前后指针法 动态演示:
在这里插入图片描述
前后指针法主要思想:事实上这里定义的并不是真正的指针,而是整形来模拟指针。 将初始位置定义为前指针int prev = begin;,后一个位置定义为后指针int cur = begin + 1;,并记录基准值int key = a[begin];当后指针指向的元素大于key时,++cur;若找到了小于key的值,那么就++prev,在判断prev != cur之后,就交换前后指针对应的值(Swap(&a[prev], &a[cur]));若相等则跳过。最后在交换基准值和前指针对应的元素(Swap(&a[prev], &a[keyi])),并返回前指针对应元素下标(return prev;)。

  • cur遇到比key大的值,++cur
  • cur遇到比key小的值,Swap(&a[prev], &a[cur])++cur++prev

前后指针法代码:

//前后指针法
int partion(int* a, int begin, int end)
{int prev = begin, cur = begin + 1;int keyi = begin;//注意此处 <=while(cur <= end){//将两种逻辑合二为一if(a[cur] < a[keyi] && ++prev != cur)Swap(&a[prev], &a[cur]);++cur;}Swap(&a[prev], &a[keyi]);return prev;
}

1.3 快速排序优化

1.3.1 三数取中法选key

考虑下面这种情况:当数组已经有序或者极其接近有序时,再使用递归法写快速排序,时间复杂度如何?

此时基准值如果还选择待排序数组第一个元素的话,那么每层递归便缺少基准值左部分的递归(即begin >= end),只有右部分, 这样待排序的数组只减少了一个元素,递归深度由原来的log(N)变成了N,时间复杂度也随之变成了O(N^2)

于是乎,一般会选择三数取中法来确定基准值,这样选出来的数既不会是最大值,也不会是最小值。三数指的是:待排序数组第一个元素a[begin],待排序数组最后一个元素a[end],待排序数组中间那个数a[(begin + end) / 2];取中指:取这三个数的中位数。 取到之后与初始值交换 Swap(&a[midi], &a[begin]);,确保第一个值为中位数。实现代码如下:

//三数取中
int GetMidi(int* a, int begin, int end)
{int midi = (begin + end) / 2;//begin  midi  end  三个数选中位数if(a[begin] < a[midi]){if(a[midi] < a[end])return midi;else if(a[begin] > a[end])return begin;elsereturn end;}else //a[begin] >= a[midi]{if(a[midi] > a[end])return midi;else if(a[end] > a[bedin])return begin;elsereturn end;}
}int midi = GetMidi(a, begin, end);
Swap(&a[midi], &a[begin]);

1.3.2 递归到小的子区间使用插入排序

为什么说递归到小的子区间要使用插入排序呢? 根据这里写的递归的特性,可以看出整体的逻辑是一棵二叉树。说到二叉树,二叉树最后一层的节点数大约占整个二叉树的节点数的一半,这样一来时间复杂度便会升高。那么我们只需要想办法将最后两三层递归逻辑,使用其他效率高的排序给替换掉即可。 这样一来如果替换掉两层,就减少了大约75%的递归,替换三层,大约就减少了87.5%的递归。

小区间优化代码如下:

//小区间优化
void QuickSort(int* a, int begin, int end)
{if(begin >= end)return;if(end - begin + 1 <= 10){//end - begin + 1 <= 10 此逻辑大约优化了三层//插入排序InsertSort(a + begin, end - begin + 1);}else{int keyi = partion(a, begin, end);QuickSort(a, begin, keyi - 1);QuickSort(a, keyi + 1, end);}
}

事实上,在如今的编译器上,此优化是微乎其微的,因为编译器已经帮助我们进行了很多优化,特别是在release版编译程序时。那么此处为什么选择直接插入排序?根据其特性,元素集合越接近有序,直接插入排序算法的时间效率越高。且此时待排序数组的元素个数较少,不适合希尔排序,且他是一种稳定的排序算法。

1.4 快排非递归版

根据递归版快排的特性,相当于二叉树的前序遍历,那么我们便可利用栈后进先出的特性,来模拟递归并实现排序,栈的实现还请参考:【数据结构和算法】— 栈。快排非递归整体逻辑大致如下:

在这里插入图片描述

在实现时我们要先创建栈并初始化,然后进栈一对数据(整个待排序数组的下标范围), 以!STEmpty(&s)作为循环条件,当栈中无节点时,便会结束。每进栈一次,便出栈顶两元素作为此次排序的范围,然后进栈div左右两部分的范围,当然只有范围中有一个数据以上才会进栈(即left < div - 1right > div + 1)。

//非递归,栈模拟
void QuickSortNonR(int* a, int begin, int end)
{ST s;STInit(&s);//先进栈一对数据STPush(&s, end);STPush(&s, begin);while(!STEmpty(&s)){//出栈一对数据,为此次排序范围int left = STTop(&s);STPop(&s);int right = STTop(&s);STPop(&s);int div = partion(a, begin, end);//div 右部分进栈if(right > div + 1){STPush(&s, right);STPush(&s, div + 1);}//div 左部分进栈if(left < div - 1){STPush(&s, div - 1);STPush(&s, left);}}
}

快速排序的特性总结:

  1. 快速排序整体的综合性能和使用场景都是比较好的,所以才敢叫快速排序;

  2. 时间复杂度: O(N*logN)
    在这里插入图片描述

  3. 空间复杂度: O(logN)

  4. 稳定性: 不稳定

二、归并排序

2.1 归并排序

基本思想:
归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide andConquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。 归并排序核心步骤:

在这里插入图片描述

归并排序 动态演示:

在这里插入图片描述

2.1.1 递归版

递归版的归并排序,逻辑上与二叉树的后序遍历十分相似。可先找到待排序数组的中间那个数的下标int mid = (begin + end) / 2;将左部分[begin, mid]作为左子树,右部分[mid + 1, end]作为右子树,继续递归,直到begin >= end(即当前元素个数小于等于一个)结束并返回,当左右部分递归完便开始合并。

此处合并即为两待排序数组[begin, mid][mid + 1, end],向动态开辟的数组tmp中拷贝并排序。 至于合并的逻辑就十分简单,两待排序数组元素依次比较,小的拷贝进tmp,直到一方拷贝完begin1 > end1begin2 > end2,然后直接拷贝未拷贝完的一方,最后再使用memcpy()函数将tmp中数据(此时tmp中元素已有序)拷回a中。

代码如下:

//递归版 归并排序
void _MergeSort(int* a, int begin, int end, int* tmp)
{if(begin >= end)return;int mid = (begin + end) / 2;//[begin, mid]  [mid + 1, end]_MergeSort(a, begin, mid, tmp);_MergeSort(a, mid + 1, end, tmp);//归并int begin1 = begin, end1 = mid;int begin2 = mid + 1, end2 = end;int i = begin;//将两个数组合并为一个,并排为升序while(begin1 <= end1 && begin2 <= end2){if(a[begin1] < a[begin2])tmp[i++] = a[begin1++];elsetmp[i++] = a[begin2++];}//拷贝剩余数据while(begin1 <= end1)tmp[i++] = a[begin1++];while(begin2 <= end2)tmp[i++] = a[begin2++];//拷贝回原数组memcpy(a + begin, tmp + begin, sizeof(int)* (end - begin + 1));
}void MergeSort(int* a, int n)
{int* tmp = (int*)malloc(sizeof(int)* n);if(tmp == NULL){perror("malloc fail");return;}_MergeSort(a, 0, n - 1, tmp);free(tmp);
}

2.1.2 非递归版

归并排序非递归版与递归相似,使用循环来模拟递归的合并逻辑定义变量int gap来表示所需合并的两数组的长度,动态开辟长度为n的数组来存储合并后的数组,用i来控制待合并数组的初始下标for(size_t i = 0; i < n; i += 2*gap)(长度小于数组长度,一次跳过两gap)。

在这里插入图片描述

根据i确定好两待合并数组的首元素下标begin,尾元素下标end然后将两个数组合并为一个,并排为升序。在确定beginend时要注意边界条件的处理(即最后一对待排序数组下标可能超出n),大致分为以下几种情况:

在这里插入图片描述
当情况1时,因为只有一个待排序数组[begin1, end1],且此数组已有序所以无需进行合并排序操作,直接break即可;而情况2,是两个待排序数组,需要合并,但第二个数组可能超出了a数组的范围,所以要缩小end2(即end2 = n - 1)。

代码如下:

//递归版 归并排序
void MergeSort(int* a, int n)
{int* tmp = (int*)malloc(sizeof(int)* n);if(tmp == NULL){perror("malloc fail");return;}int gap = 1;while(gap < n){for(size_t i = 0; i < n; i += 2*gap){int begin1 = i, end1 = i + gap - 1;int begin2 = i + gap, end2 = i + 2*gap - 1;//边界处理if(end1 >= n || begin2 >= n)break;if(end2 >= n)end2 = n - 1;//[begin1, end1]  [begin2, end2]  归并int j = begin1;//将两个数组合并为一个,并排为升序while(begin1 <= end1 && begin2 <= end2){if(a[begin1] < a[begin2])tmp[j++] = a[begin1++];elsetmp[j++] = a[begin2++];}//拷贝剩余数据while(begin1 <= end1)tmp[j++] = a[begin1++];while(begin2 <= end2)tmp[j++] = a[begin2++];//拷贝回原数组memcpy(a + i, tmp + i, sizeof(int)* (end2 - i + 1));}gap *= 2;}free(tmp);
}

在非递归的归并排序中,有这么两个问题值得思考:

  1. 对比栈实现快排的非递归,归并排序为什么不可以使用栈?
    两种排序的非递归写法,本质上与二叉树遍历极其相似。区别在于快速排序的非递归相当于二叉树的前序遍历,可以利用栈后进先出的特性来实现;而归并排序相当于二叉树的后序遍历,只能用循环来模拟实现。

  2. 上面代码中memcpy()函数的拷贝操作与放在for循环外对比!
    放在for循环内(即每归并一小段,就放回原数组a中),这样避免了随机值。因为当情况1时,break了,后面的数据(最后一组)并没有放到动态开辟的数组tmp,从而导致访问到随机值(即因为拷贝操作放在for循环外,全部数据,统一拷贝,最后一对数据memcpy()时,会遇到随机值

归并排序的特性总结:

  1. 归并的缺点在于需要O(N)的空间复杂度,归并排序的思考更多的是解决在磁盘中的外排序问题。
  2. 时间复杂度: O(N*logN)
  3. 空间复杂度: O(N)
  4. 稳定性: 稳定

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

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

相关文章

VSCode:替换空行

有时从不同的编辑器拷贝过来的代码会有很多空行&#xff0c;可以通过以下办法进行删除&#xff1a; 1.按CtrlH弹出替换窗口 2.在查找输入框中输入&#xff1a;^\s*(?\r?$)\n 3.点击使用正则表达式 4.点击全部替换

3d渲染100农场如何使用?渲染100邀请码1a12

3d渲染农场通常用于电影、动画或视觉效果的渲染&#xff0c;本文以广受好评的渲染100农场为例&#xff0c;来讲解它的使用方法。 1、注册账号 前往渲染100官网(http://www.xuanran100.com/?ycode1a12)注册账号&#xff0c; 新用户注册记得填邀请码1a12&#xff0c;有30元大礼…

【软件设计师】——面向对象设计原则

为了提高软件的可维护性、可复用性&#xff0c;增加软件的可扩展性和灵活性&#xff0c;在面向对象编程的过程中我们需要遵守以下六条原则。 开闭原则 定义&#xff1a; 编写的代码需要对 扩展开放 对 修改关闭 &#xff0c;实现 热插拔 的效果。 例&#xff1a;在编写不同皮…

【linux系统体验】-archlinux简易折腾

archlinux 一、系统安装二、系统配置及美化2.1 中文输入法2.2 安装virtualbox增强工具2.3 终端美化2.4 桌面面板美化 三、常用命令 一、系统安装 安装步骤人们已经总结了很多很全: Arch Linux图文安装教程 大体步骤&#xff1a; 磁盘分区安装 Linux内核配置系统&#xff08;…

css2复合选择器

一.后代&#xff08;包含&#xff09;选择器&#xff08;一样的标签可以用class命名以分别&#xff09; 空格表示 全部后代 应用 二.子类选择器 >表示 只要子不要孙 应用 三.并集选择器 &#xff0c;表示 代表和 一般竖着写 应用 四.伪类选择器&#xff08;包括伪链接…

【JAVA WEB】 百度热榜实现 新闻页面 Chrome 调试工具

目录 百度热榜 新闻页面 Chrome 调试工具 --查看css属性 打开调试工具的方式 标签页含义 百度热榜 实现效果&#xff1a; 实现代码 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta name"vi…

无人机应用场景和发展趋势,无人机技术的未来发展趋势分析

随着科技的不断发展&#xff0c;无人机技术也逐渐走进了人们的生活和工作中。无人机被广泛应用于很多领域&#xff0c;例如遥感、民用、军事等等。本文将围绕无人机技术的应用场景和发展趋势&#xff0c;从多角度展开分析。 无人机技术的应用场景 无人机在遥感方面的应用&…

Linux(Ubuntu) 环境搭建:Nginx

注&#xff1a;服务器默认以root用户登录 NGINX 官方网站地址&#xff1a;https://nginx.org/en/NGINX 官方安装文档地址&#xff1a;https://nginx.org/en/docs/install.html服务器的终端中输入以下指令&#xff1a; # 安装 Nginx apt-get install nginx # 查看版本信息 ngi…

###C语言程序设计-----C语言学习(11)#数据的存储和基本数据类型

前言&#xff1a;感谢您的关注哦&#xff0c;我会持续更新编程相关知识&#xff0c;愿您在这里有所收获。如果有任何问题&#xff0c;欢迎沟通交流&#xff01;期待与您在学习编程的道路上共同进步。 一. 数据的存储 1.整型数据的存储 计算机处理的所有信息都以二进制形式表示…

电子电器架构 —— 对车载软件开发新阶段的愿景

电子电器架构 —— 对车载软件开发新阶段的愿景 我是穿拖鞋的汉子,魔都中坚持长期主义的汽车电子工程师(Wechat:gongkenan2013)。 老规矩,分享一段喜欢的文字,避免自己成为高知识低文化的工程师: 本就是小人物,输了就是输了,不要在意别人怎么看自己。江湖一碗茶,喝…

51单片机编程应用(C语言):篮球比赛计分器

设计思路 1.LCD1602显示A 000:B 000 右下角显示24的数字&#xff0c;显示一节时间12&#xff1a;00. 2.规定矩阵键盘每一位表示的含义 s1按下&#xff0c;A队加一分 s2按下&#xff0c;A队加两分 s3按下&#xff0c;A队加三分 s4按下&#xff0c;A队减一分 如…

【EAI 014】Gato: A Generalist Agent

论文标题&#xff1a;A Generalist Agent 论文作者&#xff1a;Scott Reed, Konrad Zolna, Emilio Parisotto, Sergio Gomez Colmenarejo, Alexander Novikov, Gabriel Barth-Maron, Mai Gimenez, Yury Sulsky, Jackie Kay, Jost Tobias Springenberg, Tom Eccles, Jake Bruce,…

【C++】多态语法概念

目录 一、概念及定义二、虚函数重写的特例三、final和override四、抽象类 一、概念及定义 概念&#xff1a;在继承关系下的不同类&#xff0c;调用同一个函数&#xff0c;产生不同的行为&#xff0c;叫作多态。 图示&#xff1a; 定义&#xff1a;必须通过基类的指针或者引…

深度学习的新进展:解析技术演进与应用前景

深度学习的新进展&#xff1a;解析技术演进与应用前景 深度学习&#xff0c;作为人工智能领域的一颗璀璨明珠&#xff0c;一直以来都在不断刷新我们对技术和未来的认知。随着时间的推移&#xff0c;深度学习不断迎来新的进展&#xff0c;这不仅推动了技术的演进&#xff0c;也…

对话模型Demo解读(使用代码解读原理)

文章目录 前言一、数据加工二、模型搭建三、模型训练1、构建模型2、优化器与损失函数定义3、模型训练 四、模型推理五、所有Demo源码 前言 对话模型是一种人工智能技术&#xff0c;旨在使计算机能够像人类一样进行对话和交流。这种模型通常基于深度学习和自然语言处理技术&…

HTTP 超文本传送协议

1 超文本传送协议 HTTP HTTP 是面向事务的 (transaction-oriented) 应用层协议。 使用 TCP 连接进行可靠的传送。 定义了浏览器与万维网服务器通信的格式和规则。 是万维网上能够可靠地交换文件&#xff08;包括文本、声音、图像等各种多媒体文件&#xff09;的重要基础。 H…

HarmonyOS 开发学习笔记

HarmonyOS 开发学习笔记 一、开发准备1.1、了解ArkTs语言1.2、TypeScript语法1.2.1、变量声明1.2.2、条件控制1.2.3、函数1.2.4、类和接口1.2.5、模块开发 1.3、快速入门 二、ArkUI组件2.1、Image组件2.2、Text文本显示组件2.3、TextInput文本输入框组件2.4、Button按钮组件2.5…

开源个人订阅跟踪器Wallos

本文软件由网友 P家单推人 推荐&#xff1b; 什么 Wallos &#xff1f; Wallos 是一款功能强大、开源且可自我托管的网络应用程序&#xff0c;旨在让您轻松管理财务。告别复杂的电子表格和昂贵的财务软件–Wallos简化了跟踪费用的过程&#xff0c;帮助您更好地控制财务生活。 软…

LeetCode---383周赛

题目列表 3028. 边界上的蚂蚁 3029. 将单词恢复初始状态所需的最短时间 I 3030. 找出网格的区域平均强度 3031. 将单词恢复初始状态所需的最短时间 II 一、边界上的蚂蚁 这题没什么好说的&#xff0c;模拟就行&#xff0c;本质就是看前缀和有几个为0。 代码如下 class S…

Spring Cloud Hystrix 参数配置、简单使用、DashBoard

Spring Cloud Hystrix 文章目录 Spring Cloud Hystrix一、Hystrix 服务降级二、Hystrix使用示例三、OpenFeign Hystrix四、Hystrix参数HystrixCommand.Setter核心参数Command PropertiesFallback降级配置Circuit Breaker 熔断器配置Metrix 健康统计配置Request Context 相关参数…