常见排序集锦-C语言实现数据结构

目录

排序的概念

常见排序集锦

     1.直接插入排序

     2.希尔排序

     3.选择排序

     4.堆排序

     5.冒泡排序

     6.快速排序

            hoare 

            挖坑法

            前后指针法

            非递归

     7.归并排序

            非递归

排序实现接口

算法复杂度与稳定性分析


排序的概念
      排序 :所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。
    

这里推荐一个网站 数据结构和算法动态可视化 (Chinese) - VisuAlgo

它可以让我们更加清晰的看清楚排序的过程。

排序实现接口

                                                                 sort.h

#include<stdlib.h>
#include<stdio.h>
#include<assert.h>
#include<time.h>// 插入排序
void InsertSort(int* a, int n);// 希尔排序
void ShellSort(int* a, int n);// 选择排序
void SelectSort(int* a, int n);// 堆排序
void AdjustDwon(int* a, int n, int root);
void HeapSort(int* a, int n);// 冒泡排序
void BubbleSort(int* a, int n)// 快速排序递归实现// 1.快速排序hoare版本
int PartSort1(int* a, int left, int right);// 2.快速排序挖坑法
int PartSort2(int* a, int left, int right);// 3.快速排序前后指针法
int PartSort3(int* a, int left, int right);void QuickSort(int* a, int left, int right);// 快速排序 非递归实现
void QuickSortNonR(int* a, int left, int right)// 归并排序递归实现
void MergeSort(int* a, int n)// 归并排序非递归实现
void MergeSortNonR(int* a, int n)

                                            

1.插入排序

思想:把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中,直到所有的记录插入完为止,得到一个新的有序序列

实现:
void InsertSort(int* arr, int n)
{// i< n-1 最后一个位置就是 n-2for (int i = 0; i < n - 1; i++){//[0,end]的值有序,把end+1位置的值插入,保持有序int end = i;int tmp = arr[end + 1];while (end >= 0){if (tmp < arr[end]){arr[end + 1] = arr[end];end--;}else{break;}}arr[end + 1] = tmp; // why?  end+1 //break 跳出 插入 因为上面end--;//为什么不在else那里插入?因为极端环境下,假设val = 0,那么end-- 是-1,不进入while , //所以要在外面插入}
}

为什么这里 for 循环 i < n-1 ? 如图所示:


2.希尔排序

希尔排序又称缩小增量法,思想 :算法先将要排序的一组数按某个增量 gap 分成若干组,每组中记录的下标相差 gap .对每组中全部元素进行排序,然后再用一个较小的增量对它进行分组,在每组中再进行排序。当增量减到1时( == 直接插入排序),整个要排序的数被分成一组,排序完成。

希尔排序可以理解为两个步骤:1.预排序 2.直接插入排序

 

如下图:

 实现:①

void ShellSort(int* arr, int n)
{int gap = n;while (gap > 1){gap = gap / 3 + 1;  //gap = gap / 2;for (int j = 0; j < gap; j++){for (int i = j; i < n - gap; i = i + gap){int end = i;int tmp = arr[end + gap];while (end >= 0){if (tmp < arr[end]){arr[end + gap] = arr[end];end = end - gap;}else{break;}}arr[end + gap] = tmp;}}
}

②:在①的基础上进行简单的优化

void ShellSort(int* arr, int n)
{//gap > 1 时 ,预排序//gap = 1 时,直接插入排序int gap = n;while (gap > 1){gap = gap / 3 + 1;  //加1意味着最后一次一定是1 ,当gap = 1 时,就是直接排序//gap = gap / 2;for (int i = 0; i < n - gap; i++){int end = i;int tmp = arr[end + gap];while (end >= 0){if (tmp < arr[end]){arr[end + gap] = arr[end];end = end - gap;}else{break;}}arr[end + gap] = tmp;}}}
为什么for循环内,i < n-gap  ?

 

gap的取值?

这里看个人习惯,上述中是gap一开始为n,进入循环后每次 /3 ,之所以+1是为了保证最后一次循环gap一定为1。当然 /2 也是可以的,/2 就可以最后不用+1。

希尔排序的特性总结:

1. 希尔排序是对直接插入排序的优化。
2. gap > 1 时都是预排序,目的是让数组更接近于有序。当 gap == 1 时,数组已经接近有序的了,这样就会很快。这样整体而言,可以达到优化的效果。
3. 希尔排序的时间复杂度不好计算,因为 gap 的取值方法很多,导致很难去计算,希尔排序的时间复杂度都不固定。
4.排升序,gap 越大,大的数更快到后面,小的数可以更快到前面,但是越不接近有序
                  gap越小,越接近有序 ,当gap = 1 时,就是直接插入排序。

3.选择排序

思想:每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完 。

实现:这里简单做了一下优化,每次遍历不仅仅选出最小的,也选出最大的。

void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}void SelectSort(int* arr, int n)
{assert(arr);int left = 0; //开始位置int right = n - 1; //结束位置while (left < right){int min = left;int max = left;for (int i = left + 1; i <= right; i++){if (arr[i] < arr[min])min = i;if (arr[i] > arr[max])max = i;}Swap(&arr[left], &arr[min]);//如果 left 和 max 重叠 ,那么要修正 max 的位置if (left == max){max = min;}Swap(&arr[right], &arr[max]);left++;right--;}}


4.堆排序

思想:堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法,它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆,排降序建小堆。

 

实现:建堆方式有两种,这里采用向下调整方式建堆

typedef int HPDataType;void Swap(HPDataType* p1, HPDataType* p2)
{HPDataType tmp = *p1;*p1 = *p2;*p2 = tmp;
}void AdjustDown(HPDataType* arr, int size, int parent)//向下调整
{int child = parent * 2 + 1;while (child < size){if (arr[child + 1] > arr[child] && child + 1 < size){child++;}if (arr[child] > arr[parent]){Swap(&(arr[child]), &(arr[parent]));parent = child;child = (parent * 2) + 1;}else{break;}}}void HeapSort(int* arr, int n)
{//建堆for (int i = (n - 1 - 1) / 2; i >= 0; i--){AdjustDown(arr, n, i);}//排序int end = n - 1;while (end > 0){Swap(&(arr[0]), &(arr[end]));AdjustDown(arr, end, 0);end--;}}


5.冒泡排序

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

可参考:冒泡

实现:

void BubbleSort(int* arr, int n)
{assert(arr);for (int i = 0; i < n; i++){int flag = 1;for (int j = 0; j < n - i - 1; j++){if (arr[j] > arr[j + 1]){Swap(&arr[j], &arr[j + 1]);flag = 0;}}//如果没有发生交换,说明有序,直接跳出if (flag == 1)break;}}


6.快速排序

思想:任取待排序元素序列中的某元素作为基准值,按照该排序码将待排序集合分割成两子序列,左子序列中所有元素均小于基准值,右子序列中所有元素均大于基准值,然后最左右子序列重复该过程,直到所有元素都排列在相应位置上为止

hoare版本

 

 

 方法如下:

void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}int PartSort1(int* arr, int begin, int end)
{int left = begin;int right = end;//keyi 意味着保存的是 key 的位置int keyi = left;while (left < right){//右边先走,找小while (left < right && arr[right] >= arr[keyi]){right--;}//左边再走,找大while (left < right && arr[left] <= arr[keyi]){left++;}//走到这里意味着,右边的值比 key 小,左边的值比 key 大Swap(&arr[left], &arr[right]);}//走到这里 left 和 right 相遇 Swap(&arr[keyi], &arr[left]);keyi = left; //需要改变keyi的位置return keyi;
}

挖坑法

 

 方法如下:

int PartSort2(int* arr, int begin, int end)
{int key = arr[begin];int piti = begin;while (begin < end){//右边先走,找小,填到左边的坑里去,这个位置形成新的坑while (begin < end && arr[end] >= key){end--;}arr[piti] = arr[end];piti = end;//左边再走,找大while (begin < end && arr[begin] <= key){begin++;}arr[piti] = arr[begin];piti = begin;}//相遇一定是在坑位arr[piti] = key;return piti;}

前后指针法

 方法如下:

int PartSort3(int* arr, int begin, int end)
{int key = begin;int prev = begin;int cur = begin + 1;//优化-三数取中int midi = GetMidIndex(arr, begin, end);Swap(&arr[key], &arr[midi]);while (cur <= end){if (arr[cur] < arr[key] && prev != cur ){prev++;Swap(&arr[prev], &arr[cur]);}cur++;}Swap(&arr[key], &arr[prev]);key = prev;return key;
}

实现:以上三种方法都是采用函数的方式实现,这样方便调用。另外,以上方法都是单趟排序,如果要实现完整的排序还是要采用递归的方法,类似于二叉树的前序遍历

void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}void QuickSort(int* arr, int begin,int end)
{//当区间不存在或者区间只要一个值,递归返回条件if (begin >= end){return;}if (end - begin > 20) //小区间优化一般在十几{//int keyi = PartSort1(arr, begin, end);//int keyi = PartSort2(arr, begin, end);int keyi = PartSort3(arr, begin, end);//[begin , keyi - 1] keyi [keyi + 1 , end]//如果 keyi 的左区间有序 ,右区间有序,那么整体就有序QuickSort(arr, begin, keyi - 1);QuickSort(arr, keyi + 1, end);}else{InsertSort(arr + begin, end - begin + 1);//为什么+begin,因为排序不仅仅排序左子树,还有右子树//为什么+1 ,因为这个区间是左闭右闭的区间.例:0-9 是10个数 所以+1}
}

优化:

1. 三数取中法选key
2. 递归到小的子区间时,可以考虑使用插入排序(已在实现中使用)
int GetMidIndex(int* arr, int begin, int end)
{//begin   mid    endint mid = (begin + end) / 2;if (arr[begin] < arr[mid]){if (arr[mid] < arr[end]){return mid;}else if(arr[begin] < arr[end])  //走到这里说明 mid 是最大的{return end;}else{return begin;}}else // arr[begin] > arr[mid]{if (arr[mid] > arr[end]){return mid;}else if (arr[begin] < arr[end])  // 走到这里就是 begin end 都大于 mid{return begin;}else{return end;}}
}

非递归版本

非递归版本需要用到栈,这里是用c语言实现,所以需要手动实现一个栈

如果使用c++的话,可以直接引用栈。

这里栈的实现暂时省略,后期会给出链接。这里暂时知道一下就行。

 简图:

//非递归
//递归问题:极端场景下,深度太深,会出现栈溢出
//1.直接改成循环--例:斐波那契数列、归并排序
//2.用数据结构栈模拟递归过程
void QuickSortNonR(int* arr, int begin, int end)
{ST st;StackInit(&st);StackPush(&st, end);StackPush(&st, begin);while (!StackEmpty(&st)){int left = StackTop(&st);StackPop(&st);int right = StackTop(&st);StackPop(&st);int keyi = PartSort3(arr, left, right);//[left , keyi - 1]   keyi    [keyi + 1 , right]if (keyi + 1 < right){StackPush(&st, right);StackPush(&st, keyi + 1);}if (left < keyi - 1){StackPush(&st, keyi - 1);StackPush(&st, left);}}StackDestory(&st);
}


7.归并排序

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

 实现:

void _MergeSort(int* arr, int begin, int end, int* tmp)
{if (begin >= end)return;int mid = (begin + end) / 2;//[begin mid]  [mid+1,end]//递归_MergeSort(arr, begin, mid, tmp);_MergeSort(arr, mid + 1, end, tmp);//归并[begin mid]  [mid+1,end]int left1 = begin;int right1 = mid;int left2 = mid + 1;int right2 = end;int i = begin;//这里之所以等于begin 而不是等于0 是因为可能是右子树而不是左子树 i为tmp数组下标while (left1 <= right1 && left2 <= right2){if (arr[left1] < arr[left2]){tmp[i++] = arr[left1++];}else{tmp[i++] = arr[left2++];}}//假如一个区间已经结束,另一个区间直接拿下来while (left1 <= right1){tmp[i++] = arr[left1++];}while (left2 <= right2){tmp[i++] = arr[left2++];}//把归并的数据拷贝回原数组 [begin mid]  [mid+1,end]// +begin 是因为可能是右子树    例:[2,3][4,5]//+1 是因为是左闭右闭的区间 0-9 是10个数据memcpy(arr + begin, tmp + begin, (end - begin + 1) * sizeof(int));}void MergeSort(int* arr, int n)
{int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL){perror("malloc");exit(-1);}_MergeSort(arr, 0, n - 1, tmp);free(tmp);
}

 

非递归版本:

思想:这里不能使用栈或者队列,因为栈或者队列适合前序遍历的替换,但是归并排序的思想属于后序遍历,栈和队列的特性导致后期可能无法使用前面的空间。

        这里因为是循环,所以可以设计一个变量 gap,当gap= 1 ,就一一进行归并,当gap = 2时,就两两进行归并,gap 每次 *2 。

如图:

 代码如下:

void MergeSortNonR(int* arr, int n)
{int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL){perror("malloc");exit(-1);}int gap = 1;while (gap < n){for (int i = 0; i < n; i += 2 * gap){//[i , i + gap-1]  [i + gap , i + 2*gap-1]int left1 = i;int right1 = i + gap - 1;int left2 = i + gap;int right2 = i + 2 * gap - 1;int j = left1;while (left1 <= right1 && left2 <= right2){if (arr[left1] < arr[left2]){tmp[j++] = arr[left1++];}else{tmp[j++] = arr[left2++];}}while (left1 <= right1){tmp[j++] = arr[left1++];}while (left2 <= right2){tmp[j++] = arr[left2++];}}memcpy(arr, tmp, sizeof(int) * n);gap *= 2;}free(tmp);
}

       但是上述代码涉及到一个问题,因为假设要排序的数据不是2的次方倍就会产生问题(和数据的奇偶无关),就会越界

例:

 所以我们需要对代码进行优化, 优化可以从两个方面进行:    

//1.归并完成全部拷贝回原数组
//采用修正边界的方法
//例:如果是9个数据 最后一个数据也要继续进行归并
//因为如果不归并的话,最后一次会全部拷贝回原数组,也就意味着9个数据,前8个归并,拷贝回去的最后一个数据因为没有进行归并而产生随机值。

//如果越界,就修正边界,继续进行归并

代码如下:

void MergeSortNonR(int* arr, int n)
{int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL){perror("malloc");exit(-1);}int gap = 1;while (gap < n){//printf("gap=%d->", gap);for (int i = 0; i < n; i += 2 * gap){//[i , i + gap-1]  [i + gap , i + 2*gap-1]int left1 = i;int right1 = i + gap - 1;int left2 = i + gap;int right2 = i + 2 * gap - 1;//监测是否出现越界//printf("[%d,%d][%d,%d]---", left1, right1, left2, right2);//修正边界if (right1 >= n){right1 = n - 1;//[left2 , right2] 修正为一个不存在的区间left2 = n;right2 = n - 1;}else if (left2 >= n){left2 = n;right2 = n - 1;}else if (right2 >= n){right2 = n - 1;}//printf("[%d,%d][%d,%d]---", left1, right1, left2, right2);int j = left1;while (left1 <= right1 && left2 <= right2){if (arr[left1] < arr[left2]){tmp[j++] = arr[left1++];}else{tmp[j++] = arr[left2++];}}while (left1 <= right1){tmp[j++] = arr[left1++];}while (left2 <= right2){tmp[j++] = arr[left2++];}}//printf("\n");memcpy(arr, tmp, sizeof(int) * n);gap *= 2;}free(tmp);
}

2.归并一组数据就拷贝一组数据回原数组

这样,如果越界就直接break跳出循环,后面的数据不进行归并。

void MergeSortNonR_2(int* arr, int n)
{int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL){perror("malloc");exit(-1);}int gap = 1;while (gap < n){for (int i = 0; i < n; i += 2 * gap){//[i , i + gap-1]  [i + gap , i + 2*gap-1]int left1 = i;int right1 = i + gap - 1;int left2 = i + gap;int right2 = i + 2 * gap - 1;//right1 越界 或者 left2 越界,则不进行归并if (right1 >= n || left2 > n){break;}else if (right2 >= n){right2 = n - 1;}int m = right2 - left1 + 1;//实际归并个数int j = left1;while (left1 <= right1 && left2 <= right2){if (arr[left1] < arr[left2]){tmp[j++] = arr[left1++];}else{tmp[j++] = arr[left2++];}}while (left1 <= right1){tmp[j++] = arr[left1++];}while (left2 <= right2){tmp[j++] = arr[left2++];}memcpy(arr+i, tmp+i, sizeof(int) * m);}gap *= 2;}free(tmp);
}

以上两种方式的代码皆可,具体重要的还是思想。


算法复杂度与稳定性分析

       稳定性:假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次 序保持不变,即在原序列中,r[i]=r[j],且r[i]r[j]之前,而在排序后的序列中,r[i]仍在r[j]之前,则称这种排 序算法是稳定的;否则称为不稳定的。

 

 

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

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

相关文章

排名前 6 位的数学编程语言

0 说明 任何对数学感兴趣或计划学习数学的人&#xff0c;都应该至少对编程语言有一定的流利程度。您不仅会更有就业能力&#xff0c;还可以更深入地理解和探索数学。那么你应该学习什么语言呢&#xff1f; 1.python 对于任何正在学习数学的人来说&#xff0c;Python都是一门很棒…

【Linux从入门到精通】动静态库的原理与制作详解

本篇文章主要是围绕动静态库的原理与制作进行展开讲解的。其中涉及到了inode的概念引入和软硬连接的讲解。会结合实际操作对这些抽象的概念进行解释&#xff0c;希望会对你有所帮助。 文章目录 一、inode 概念 二、软硬链接 2、1 软连接 2、2 硬链接 三、动静态库概念 3、1 静态…

编织梦想:SpringBoot AOP 教程与自定义日志切面完整实战

什么是 AOP AOP 是指通过预编译方式和运行期动态代理的方式&#xff0c;在不修改源代码的情况下对程序进行功能增强的一种技术。AOP 不是面向对象编程&#xff08;OOP&#xff09;的替代品&#xff0c;而是 OOP 的补充和扩展。它是一个新的维度&#xff0c;用来表达横切问题&a…

常见前端基础面试题(HTML,CSS,JS)(三)

JS 中如何进行数据类型的转换&#xff1f; 类型转换可以分为两种&#xff0c;隐性转换和显性转换 显性转换 主要分为三大类&#xff1a;数值类型、字符串类型、布尔类型 三大类的原始类型值的转换规则我就不一一列举了 数值类型&#xff08;引用类型转换&#xff09; Numbe…

设计模式之状态模式(State)的C++实现

1、状态模式的提出 在组件功能开发过程中&#xff0c;某些对象的状态经常面临变化&#xff0c;不同的状态&#xff0c;其对象的操作行为不同。比如根据状态写的if else条件情况&#xff0c;且这种条件变化是经常变化的&#xff0c;这样的代码不易维护。可以使用状态模式解决这…

如何在window下cmd窗口执行linux指令?

1.Git&#xff1a;https://git-scm.com/downloads(官网地址) 2.根据自己的实际路径,添加两个环境变量 3.重启电脑

删除有序链表中重复的元素-II(链表)

乌&#xff01;蒙&#xff01;山&#xff01;连&#xff01;着&#xff01;山&#xff01;外&#xff01;山&#xff01; 题目&#xff1a; 思路&#xff1a; 双指针&#xff0c;slow和fast&#xff0c;并且增加标记flag初始为1。 如果slow指向节点值等于fast指向节点值&…

Servlet 初步学习

文章目录 Servlet1 简介2 快速入门3 执行流程4 生命周期5 方法介绍6 体系结构7 urlPattern配置8 XML配置 Servlet 1 简介 Servlet是JavaWeb最为核心的内容&#xff0c;它是Java提供的一门 动态 web资源开发技术。 使用Servlet就可以实现&#xff0c;根据不同的登录用户在页面…

什么是cURL?

cURL无处不在。它几乎隐藏在所有设备中&#xff0c;例如汽车&#xff0c;蓝光播放器等。它通过互联网协议传输任意类型数据。 在本文中&#xff0c;我们将揭开cURL神秘命令行工具的面纱&#xff0c;解释它是如何成为一种通用代码的&#xff0c;并举例说明其用法。 cURL是什么意…

PHP海外代购管理系统mysql数据库web结构apache计算机软件工程网页wamp

一、源码特点 PHP 海外代购管理系统是一套完善的web设计系统&#xff0c;对理解php编程开发语言有帮助&#xff0c;系统具有完整的源代码和数据库&#xff0c;系统主要采用B/S模式开发。 代码下载 https://download.csdn.net/download/qq_41221322/88229435 论文 https://…

Redis中的分布式锁及其延生的问题

前言 本文将着重介绍Redis中的分布式锁及其与出现的死锁和锁误删问题 什么是分布式锁 首先问题就是什么是分布式锁&#xff0c;分布式锁就是分布式系统中实现并发控制的一种锁机制&#xff0c;它可以保证多个节点在同一个时间只有有一个能成功竞争到系统资源&#xff08;共享…

LeetCode算法递归类—二叉树中的最大路径和

目录 124. 二叉树中的最大路径和 - 力扣&#xff08;LeetCode&#xff09; 题解&#xff1a; 代码&#xff1a; 运行结果&#xff1a; 二叉树中的 路径 被定义为一条节点序列&#xff0c;序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 至多出现一次 。该…

基于Opencv的虚拟拖拽项目

预备知识 勾股定理 跟随移动算法 手势识别图解 项目源代码 """ 演示一个简单的虚拟拖拽 步骤&#xff1a; 1、opencv 读取视频流 2、在视频图像上画一个方块 3、通过mediapipe库获取手指关节坐标 4、判断手指是否在方块上 5、是&#xff0c;方块跟着移动 6、…

密码学学习笔记(十九):密码学关键术语的解释1

数据加密标准(DES) 数据加密标准是使用最广泛的加密体制&#xff0c;它于1977年被美国国家标准和技术研究所(NIST)采纳为联邦信息处理标准FIPS PUB 46。 DES3DESAES明文分组长度&#xff08;位&#xff09;6464128密文分组长度&#xff08;位&#xff09;6464128密钥长度&…

详解junit

目录 1.概述 2.断言 3.常用注解 3.1.Test 3.2.Before 3.3.After 3.4.BeforeClass 3.5.AfterClass 4.异常测试 5.超时测试 6.参数化测试 1.概述 什么是单元测试&#xff1a; 单元测试&#xff0c;是针对最小的功能单元编写测试代码&#xff0c;在JAVA中最小的功能单…

0101读写分离测试-jdbc-shardingsphere-中间件

文章目录 1 前言2、创建SpringBoot程序2.1、创建项目2.2、添加依赖2.3、生成实体类、service与Mapper1.5、配置读写分离 2、测试2.1、读写分离测试2.2、事务测试2.3、负载均衡测试 结语 1 前言 shardingshpere-jdbc定位为轻量级 Java 框架&#xff0c;在 Java 的 JDBC 层提供的…

【前端面试】中大文件上传/下载:中等文件代理服务器放行+大文件切片传输+并发请求+localstorage实现断点续传

目录 中等文件代理服务器放行&#xff1a;10MB为单位 proxy nginx 大文件切片&#xff1a;100MB为单位 断点&#xff1a;存储切片hash 前端方案A localstorage 后端方案B 服务端 上传 前端 后端 下载 前端 后端 多个大文件传输&#xff1a;spark-md5 哈希碰撞…

什么是Pytorch?

当谈及深度学习框架时&#xff0c;PyTorch 是当今备受欢迎的选择之一。作为一个开源的机器学习库&#xff0c;PyTorch 为研究人员和开发者们提供了一个强大的工具来构建、训练以及部署各种深度学习模型。你可能会问&#xff0c;PyTorch 是什么&#xff0c;它有什么特点&#xf…

JQuery快速入门教程

1、JQuery快速入门 1.1、JQuery介绍 jQuery 是一个 JavaScript 库。所谓的库&#xff0c;就是一个 JS 文件&#xff0c;里面封装了很多预定义的函数&#xff0c;比如获取元素&#xff0c;执行隐藏、移动等&#xff0c;目的就 是在使用时直接调用&#xff0c;不需要再重复定义…

微机原理与接口技术 学习笔记(二) 存储器

文章目录 一&#xff0c;存储器1.1 概述1.1.1 半导体存储器的分类按制造工艺&#xff1a; 易失性或挥发性存储器 / 不易失性或不挥发性存储器按制造工艺&#xff1a; 1.1.2 半导体存储器的性能指标1.1.3 半导体存储器的一般结构及组成 1.2 随机存取存储器 RAM1.2.1 静态RAM1.2.…