搜索
查看
编辑修改
首页
UNITY
NODEJS
PYTHON
AI
GIT
PHP
GO
CEF3
JAVA
HTML
CSS
搜索
黑客灵魂
这个屌丝很懒,什么也没留下!
关注作者
热门标签
jquery
HTML
CSS
PHP
ASP
PYTHON
GO
AI
C
C++
C#
PHOTOSHOP
UNITY
iOS
android
vue
xml
爬虫
SEO
LINUX
WINDOWS
JAVA
MFC
CEF3
CAD
NODEJS
GIT
Pyppeteer
article
热门文章
1
基于Python实现前端自动化打包部署_python 自动化部署
2
一文了解 HDFS 及其组成框架_hdfs是什么技术框架
3
如何使用Kali远程桌面访问Windows 10或11_kali远程控制windows
4
智能体——父亲兴趣爱好助手
5
【面试必备】非关系数据库的优缺点及四大分类,附带学习经验_非关系型数据库
6
使用workbench写SQL语句-初级_workbench查看表信息
7
Spark 概述以及与Hadoop的关系_spark属于hadoop组件吗
8
基于单片机的老人防摔倒的设计与实现_基于单片机的老人跌倒检测装置
9
平衡二叉树的使用_有一批学生信息,存储在文件stuinfo.txt中,学生信息的格式为: (学号(12位,关键字项
10
基于lora技术对Gemma(2B)大模型的微调实践_gemma2b 微调
当前位置:
article
> 正文
八种基本的排序算法_每趟循环只能确定一个元素排序后的位置。优化后的思想
作者:黑客灵魂 | 2024-06-26 16:11:56
赞
踩
每趟循环只能确定一个元素排序后的位置。优化后的思想
一.、直接插入排序算法(数组存储)
1.n个待排元素,分成两部分,有序部分和无序部分
2.初始:有序段:a[0]
无序段:a[1]--a[n]
3.算法实现思想
从无序中取出一个元素a[i]和有序区间元素进行比较,并且将其插入合适的位置,插入位置之后的元素要后移。
例:
{3,2,5,8,4,7,6,9}
{3}{2,5,8,4,7,6,9}
{2,3}{5,8,4,7,6,9}
{2,3,5}{8,4,7,6,9}
{2,3,5,8}{4,7,6,9}
{2,3,4,5,8}{7,6,9}
{2,3,4,5,7,8}{6,9}
{2,3,4,5,6,7,8}{9}
{2,3,4,5,6,7,8,9}
4.算法实现
void IninsertSort(inr a[],int n)
{
int i,j,x;
for(i=1;i<n;i++)
{
x=a[i];
for(j=i-1;j>-1&&a[j]>x;j--)
a[j+1]=a[j];
a[j+1]=x;
}
}
5.算法性能及其优化
空间复杂度:O(1)
时间复杂度:O(n2)
稳定性:稳定
优化:插入时对有序段从后向前查找;
找要插入的元素的位置时对有序段进行二分查找
二、冒泡排序(数组存储)
1.n个元素排完序最多经过n-1趟
2.算法实现思想
假如一组数按从小到大排序,对该组数进行两两比较,看是否需要交换,如果需要交换就交换,不需要交换就不用交换继续继续想下执行,直到这些元素都被比较过一遍之后,有一个元素放在了他最终的位置上(即:第一个或者最后一个)
例:
{3,5,6,4,2,7}
{2,3,5,6,4,7}
{2,3,4,5,6,7}
3.算法实现
void BubbleSort(int a[],int n)
{
int i,j,t;
for(i=0;i><n-1;i++)
{
for(j=n-1;j>i;j--)
{
if(a[j]>a[j-1])
{
t=a[j];
a[j]=a[j-1];
a[j-1]=t;
}
}
}
}
注:该过程需要把所有的过程跑完才结束
4.算法性能及其优化
空间复杂度:O(1)
时间复杂度:O(n2)
稳定性:稳定
优化:对外层循环设置标记符flag,只要所以元素都按顺序排完了就输出,不需要所有的都跑完;
对内层循环,从后边向前边往出冒元素
实现代码如下:
void BubbleSort(int a[],int n)
{
int i,j,t,tag;
for(i=0;i<n-1;i++)
{
tag=0;
for(j=n-1;j>i;j--)
{
t=a[j];
a[j]=a[j-1];
a[j-1]=t;
tag=1;
}
if(!tag) break;
}
}
三、快速排序
1.基本思想
(1)选择一个基准元素,,通常选择第一个或者最后一个元素
(2)通过一次排序,将待排序记录分割成两部分,其中一部分记录不基准元素小的元素,一部分记录比基准元素大的元素
(3)此时基准元素正好在排好序的正确位置上
(4)然后分别对这两部分记录用同样的方法继续进行排序,直到整个序列有序
例:
2算法实现:
递归实现:
void QuickSort(int a[],int low,int high)
{
int i, j, x;
if (low <high)
{
i = low;
j = high;
x = a[i];
while (i < j)
{
while(i < j && a[j] > x)
j--; /* 从右向左找第一个小于x的数 */
if(i < j)
a[i] = a[j];
while(i < j && a[i] < x)
i++; /* 从左向右找第一个大于x的数 */
if(i < j)
a[j] = a[i];
}
a[i] = x;
QuickSort(a, low, i-1); /* 递归调用 */
QuickSort(a, i+1, high);
}
}
非递归排序:
#include<stdio.h>
#define N 7
void QuickSort(int a[],int n)
{
for(int i=0;i<n;i++)
{
for(int j=0;j<n-i-1;j++)
{
if(a[j]>a[j+1])
{
int t=a[j];
a[j]=a[j+1];
a[j+1]=t;
}
}
}
}
//void QuickSort(int a[],int n)
//{
// for(int i=0;i<n;i++)
// {
// for(int j=i;j<n;j++)
// {
// if(a[i]>a[j])
// {
// int t=a[i];
// a[i]=a[j];
// a[j]=t;
// }
// }
// }
//}
3.算法性能及其优化
空间复杂度:O(1)
时间复杂度:O(n2) 最好情况 O(nlogn)
稳定性:不稳定
优化:
在本改进算法中
,
只对长度大于
k
的子序列递归调用快速排序
,
让原序列基本有序,然后再对整个基本有序序列用插入排序算法排序。实践证明,改进后的算法时间复杂度有所降低,且当
k
取值为
8
左右时
,
改进算法的性能最佳。算法思想如下:(连链接中有优化后的代码)
四、希尔排序
1.算法思想
先将整个待排序的记录序列分割成若干子序列分别进行插入排序,待整个序列中的记录基本有序时在对整体进行一次直接插入排序
操作如下:
选择一个增量序列个数k,对序列进行k趟排序,每趟排序,根据对应的增量d,将待排序列分成长度为m的子序列,分别对各自的表进行直接插入排序,尽因增量为1时,整个序列作为一个表来处理,表长度为整个序列的长度
例:
3.算法实现
增量序列d = {n/2 ,n/4, n/8 .....1}
n
为要排序数的个数即:先将要排序的一组记录按某个增量
d
(
n/2,n
为要排序数的个数)分成若干组子序列,每组中记录 的下 标相差
d.
对每组中全部元素进行直接插入排序,然后再用一个较小的增量(
d/2
)对它进行分组,在每组中再进行直接插入排序。继续不断缩小增量直至为
1
,最后使用直接插入排序完成排序。
void ShellSort(int a[],int n)
{
int i,j,x;
int d=n/2;
while(d>=1)
{
for(i=d;i<n;i++)
{
x=a[i];
for(j=i-d;j>=0;j-=d)
{
if(a[j]>x)
a[j+d]=a[j];
else
break;
}
a[j+d]=x;
}
d=d/2;
}
}
4.
算法性能及其优化
空间复杂度:O(1)
时间复杂度:O(n2) 最好情况 O(nlogn)
稳定性:不稳定
五、简单选择排序
1.算法思想
设所有元素的第一个元素为最大的元素(或者最小的元素),然后用第一个元素与其他元素比较,找到其中最大的(或最小的)和第一个元素交换,一次排序完,数组中第一个位置上放的是该序列完成排序后元素缩放的位置。(即一次排序完之后肯定有一个元素放到正确的位置上,后边在比较时就不用再考虑这些元素)
2.算法实现
void SelectSort(int a[],int n)
{
int i,j,kmin,t;
for(i=0;i<n;i++)
{
kmin=i;
for(j=i+1;j<n;j++)
{
if(a[kmin]>a[j])
kmin=j;
}
if(i!=kmin)
{
t=a[i];
a[i]=a[kmin];
a[kmin]=t;
}
}
}
3.算法性能及其优化
空间复杂度:O(1)
时间复杂度:O(n2)
稳定性:不稳定
优化:
简单选择排序,每趟循环只能确定一个元素排序后的定位。我们可以考虑改进为每趟循环确定两个元素(当前趟最大和最小记录)的位置
,
从而减少排序所需的循环次数。改进后对
n
个数据进行排序,最多只需进行
[n/2]
趟循环即可。具体实现如下:
void
SelectSort(
int
r[],
int
n) {
·
int
i ,j , min ,max, tmp;
for
(i=1 ;i <= n/2;i++) {
// 做不超过n/2趟选择排序
min = i; max = i ;
//分别记录最大和最小关键字记录位置
for
(j= i+1; j<= n-i; j++) {
if
(r[j] > r[max]) {
max = j ;
continue
;
}
if
(r[j]< r[min]) {
min = j ;
}
}
//该交换操作还可分情况讨论以提高效率
tmp = r[i-1]; r[i-1] = r[min]; r[min] = tmp;
tmp = r[n-i]; r[n-i] = r[max]; r[max] = tmp;
}
}
六、归并排序
1.算法思想
是将两个或者是两个以上的有序表合成一个新的有序表,即把待排序列分成若干个子序列,每个子序列是有序的,然后把有序子序列合并成整体有序序列
例如:
归并排序示例:
2.算法实现
(1)递归实现
//实现归并,并把数据都放在list1里面
void merging(int *list1,int list1_size,int *list2,int list2_size)
{
int i,j,k,m;
i = j = k = 0;
int temp[MAXSIZE];
while(i<list1_size&&j<list2_size)
{
if(list1[i] < list2[j])
{
temp[k++] = list1[i++];
}
else
{
temp[k++] = list2[j++];
}
}
//如果有剩下的,那么说明就是它是比前面的数组都大的,直接加入就可以了
while(i<list1_size)
{
temp[k++] = list1[i++];
}
while(j<list2_size)
{
temp[k++] = list2[j++];
}
for(m=0; m<(list1_size + list2_size);m++)
{
list1[m] = temp[m];
}
}
void MergeSort(int k[],int n)
{
if(n>1)
{
int *list1 = k; //定义一个指针变量,指向数组k的地址
int list1_size = n/2; //数组的长度分为本来数组长度的一半
int *list2 = k +n/2; //定义另外一个指针变量,指向数组k+n/2的地址
int list2_size = n - list1_size;//长度为刚才总的减去刚才分去那一半
MergeSort(list1,list1_size); //调用数组本身,相当与递归,
MergeSort(list2,list2_size); //调用数组本身,相当与递归
merging(list1,list1_size,list2,list2_size);
}
}
(2)迭代实现
void MergeSort(int k[],int n)
{
int i,next,left_min,left_max,right_min,right_max;
//开辟一个与原来数组一样大小的空间用来存储用
int *temp = (int *)malloc(n * sizeof(int));
//逐级上升,第一次比较2个,第二次比较4个,第三次比较8个。。。
for(i=1; i<n; i*=2)
{
//每次都从0开始,数组的头元素开始
for(left_min=0; left_min<n-i; left_min = right_max)
{
right_min = left_max = left_min + i;
right_max = left_max + i;
//右边的下标最大值只能为n
if(right_max>n)
{
right_max = n;
}
//next是用来标志temp数组下标的,由于每次数据都有返回到K,
//故每次开始得重新置零
next = 0;
//如果左边的数据还没达到分割线且右边的数组没到达分割线,开始循环
while(left_min<left_max&&right_min<right_max)
{
if(k[left_min] < k[right_min])
{
temp[next++] = k[left_min++];
}
else
{
temp[next++] = k[right_min++];
}
}
//上面循环结束的条件有两个,如果是左边的游标尚未到达,那么需要把
//数组接回去,可能会有疑问,那如果右边的没到达呢,其实模拟一下就可以
//知道,如果右边没到达,那么说明右边的数据比较大,这时也就不用移动位置了
while(left_min < left_max)
{
//如果left_min小于left_max,说明现在左边的数据比较大
//直接把它们接到数组的min之前就行
k[--right_min] = k[--left_max];
}
while(next>0)
{
//把排好序的那部分数组返回该k
k[--right_min] = temp[--next];
}
}
}
}
3.算法性能及其优化
空间复杂度:O(n+logN)
时间复杂度:O(nlog(n))
稳定性:不稳定
优化:两路归并的递算法:
void
MSort(ElemType *r, ElemType *rf,
int
s,
int
t)
{
ElemType *rf2;
if
(s==t) r[s] = rf[s];
else
{
int
m=(s+t)/2;
/*平分*p 表*/
MSort(r, rf2, s, m);
/*递归地将p[s…m]归并为有序的p2[s…m]*/
MSort(r, rf2, m+1, t);
/*递归地将p[m+1…t]归并为有序的p2[m+1…t]*/
Merge(rf2, rf, s, m+1,t);
/*将p2[s…m]和p2[m+1…t]归并到p1[s…t]*/
}
}
void
MergeSort_recursive(ElemType *r, ElemType *rf,
int
n)
{
/*对顺序表*p 作归并排序*/
MSort(r, rf,0, n-1);
}
七、堆排序
1.算法思想
堆排序是一种树形选择排序,是对直接选择排序的有效改进。(形成的树一定为完全二叉树)
堆的定义如下:具有n
个元素的序列(k1,k2,...,kn),当且仅当满足
时称之为堆。由堆的定义可以看出,
堆顶元素
(即第一个元素)必为最小项(小顶堆)。若以一维数组存 储一个堆,则堆对应一棵完全二叉树,且所有非叶结点的值均不大于(或不小于)其子女的值,根结点(堆顶元素)的值是最小(或最大)的。如:
(a)大顶堆序列:(96, 83,27,38,11,09)
(b) 小顶堆序列:(12,36,24,85,47,30,53,91)
初始时把要排序的n个数的序列看作是一棵
顺序存储的二叉树(一维数组存储二叉树)
,调整它们的存储 序,使之成为一个堆,将堆顶元素输出,得到n 个元素中最小(或最大)的元素,这时堆的根节点的数最小(或者最大)。然后对前面(n-1)个元素重新调整使之成为堆,输出堆顶元素,得到n 个元素中次小(或次大)的元素。依此类推,直到只有两个节点的堆,并对它们作交换,最后得到有n个节点的有序序列。称这个过程为
堆排序
。
因此,实现堆排序需解决两个问题:
(1) 如何将n 个待排序的数建成堆;
(2)输出堆顶元素后,怎样调整剩余n-1 个元素,使其成为一个新堆。
2.算法实现
void Make_Heap(int a[],int end)
{
int pa,t,tag=1;
while(tag)
{
pa=end/2;
tag=0;
while(pa>0)
{
if(a[pa]<a[2*pa])
{
t=a[pa];
a[pa]=a[2*pa];
a[2*pa]=t;
tag=1;
}
if(2*pa+1<=end&&a[pa]<a[2*pa+1])
{
t=a[pa];
a[pa]=a[2*pa+1];
a[2*pa+1]=t;
tag=1;
}
pa--;
}
}
}
void HeapSort(int a[])
{
int pa,p;
int end=N;
while(end>1)
{
Make_Heap(a,end);
//交换头结点好尾节点
p=a[1];
a[1]=a[end];
a[end]=p;
end--;
}
}
3.算法性能及其优化
空间复杂度:O(1)
时间复杂度:最坏
O(nlogn )
稳定性:不稳定
优化:无
八、基数排序(桶排序)
桶排序的基本思想:将阵列分布到游戏那数量的桶子里,每个桶子再个别排序(有可能在使用别的排序算法或是以递回方式继续使用桶排序进行排序),桶排序是鸽巢排序的一种归纳结果。当要被排序的阵列内的数值是均匀分配的时候,桶排序使用线性时间(O(n)).但桶排序并不是比较排序,他不受到O(nlogn)下限的影响
简单来说,就是把数据分组,放在一个个的桶中,然后对每个桶里面的在进行排序。
例如要对大小为[1..1000]范围内的n个整数A[1..n]排序 ,
首先,可以把桶设为大小为10的范围,具体而言,设集合B[1]存储[1..10]的整数,集合B[2]存储 (10..20]的整数,……集合B[i]存储( (i-1)*10, i*10]的整数,i = 1,2,..100。总共有 100个桶。
然后,对A[1..n]从头到尾扫描一遍,把每个A[i]放入对应的桶B[j]中。 再对这100个桶中每个桶里的数字排序,这时可用冒泡,选择,乃至快排,一般来说 任 何排序法都可以。
最后,依次输出每个桶里面的数字,且每个桶中的数字从小到大输出,这 样就得到所有数字排好序的一个序列了。
假设有n个数字,有m个桶,如果数字是平均分布的,则每个桶里面平均有n/m个数字。如果
对每个桶中的数字采用快速排序,那么整个算法的复杂度是
O(n + m * n/m*log(n/m)) = O(n + nlogn - nlogm)
从上式看出,当m接近n的时候,桶排序复杂度接近O(n) 当然,以上复杂度的计算是基于输入的n个数字是平均分布这个假设的。这个假设是很强的 ,实际应用中效果并没有这么好。如果所有的数字都落在同一个桶中,那就退化成一般的排序了。
前面说的几大排序算法 ,大部分时间复杂度都是O(n2),也有部分排序算法时间复杂度是O(nlogn)。而桶式排序却能实现O(n)的时间复杂度。但桶排序的缺点是:
1)首先是空间复杂度比较高,需要的额外开销大。排序有两个数组的空间开销,一个存放待排序数组,一个就是所谓的桶,比如待排序值是从0到m-1,那就需要m个桶,这个桶数组就要至少m个空间。
2)其次待排序的元素都要在一定的范围内等等。
桶式排序是一种分配排序。分配排序的特定是不需要进行关键码的比较,但前提是要知道待排序列的一些具体情况。
分配排序的基本思想:
说白了就是进行多次的桶式排序。
基数排序过程无须比较关键字,而是通过“分配”和“收集”过程来实现排序。它们的时间复杂度可达到线性阶:O(n)。
实例:
扑克牌中52 张牌,可按花色和面值分成两个字段,其大小关系为:
花色:
梅花< 方块< 红心< 黑心
面值:
2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < 10 < J < Q < K < A
若对扑克牌按花色、面值进行升序排序,得到如下序列:
即两张牌,若花色不同,不论面值怎样,花色低的那张牌小于花色高的,只有在同花色情况下,大小关系才由面值的大小确定。这就是多关键码排序。
为得到排序结果,我们讨论两种排序方法。
方法1
:先对花色排序,将其分为4 个组,即梅花组、方块组、红心组、黑心组。再对每个组分别按面值进行排序,最后,将4 个组连接起来即可。
方法2
:先按13 个面值给出13 个编号组(2 号,3 号,...,A 号),将牌按面值依次放入对应的编号组,分成13 堆。再按花色给出4 个编号组(梅花、方块、红心、黑心),将2号组中牌取出分别放入对应花色组,再将3 号组中牌取出分别放入对应花色组,……,这样,4 个花色组中均按面值有序,然后,将4 个花色组依次连接起来即可。
设n 个元素的待排序列包含d 个关键码{k1,k2,…,kd},则称序列对关键码{k1,k2,…,kd}有序是指:对于序列中任两个记录r[i]和r[j](1≤i≤j≤n)都满足下列有序关系:
其中k1 称为最主位关键码,kd 称为最次位关键码 。
两种多关键码排序方法:
多关键码排序按照从最主位关键码到最次位关键码或从最次位到最主位关键码的顺序逐次排序,分两种方法:
最高位优先(Most Significant Digit first)法,简称MSD 法
:
1)先按k1 排序
分组
,将序列分成若干子序列,同一组序列的记录中,关键码k1 相等。
2)再对各组按k2 排序分成子组,之后,对后面的关键码继续这样的排序分组,直到按最次位关键码kd 对各子组排序后。
3)再将各组连接起来,便得到一个有序序列。扑克牌按花色、面值排序中介绍的方法一即是MSD 法。
最低位优先(Least Significant Digit first)法,简称LSD 法
:
1) 先从kd 开始排序,再对kd-1进行排序,依次重复,直到按k1排序分组分成最小的子序列后。
2) 最后将各个子序列连接起来,便可得到一个有序的序列, 扑克牌按花色、面值排序中介绍的方法二即是LSD 法。
基于LSD方法的链式基数排序的基本思想
“多关键字排序”的思想实现“单关键字排序”。对数字型或字符型的单关键字,可以看作由多个数位或多个字符构成的多关键字,此时可以采用“分配-收集”的方法进行排序,这一过程称作基数排序法,其中每个数字或字符可能的取值个数称为基数。比如,扑克牌的花色基数为4,面值基数为13。在整理扑克牌时,既可以先按花色整理,也可以先按面值整理。按花色整理时,先按红、黑、方、花的顺序分成4摞(分配),再按此顺序再叠放在一起(收集),然后按面值的顺序分成13摞(分配),再按此顺序叠放在一起(收集),如此进行二次分配和收集即可将扑克牌排列有序。
基数排序:
是按照低位先排序,然后收集;再按照高位排序,然后再收集;依次类推,直到最高位。有时候有些属性是有优先级顺序的,先按低优先级排序,再按高优先级排序。最后的次序就是高优先级高的在前,高优先级相同的低优先级高的在前。基数排序基于分别排序,分别收集,所以是稳定的。
算法实现:
Void RadixSort(Node L[],length,maxradix)
{
int
m,n,k,lsp;
k=1;m=1;
int
temp[10][length-1];
Empty(temp);
//清空临时空间
while
(k<maxradix)
//遍历所有关键字
{
for
(
int
i=0;i<length;i++)
//分配过程
{
if
(L[i]<m)
Temp[0][n]=L[i];
else
Lsp=(L[i]/m)%10;
//确定关键字
Temp[lsp][n]=L[i];
n++;
}
CollectElement(L,Temp);
//收集
n=0;
m=m*10;
k++;
}
}
3.算法性能及其优化
空间复杂度:O(rd+n)
时间复杂度:最坏
O(d(r+n) )
稳定性:稳定
优化:无
声明:
本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:
https://www.wpsshop.cn/w/黑客灵魂/article/detail/759843
推荐阅读
article
2024Java
大厂
面试
题来袭
,
这是我见过最有用
的
java
面试
题
,
java
校招笔试
面试
题目_2024...
上述知识点
,
囊括了目前互联网企业
的
主流应用技术以及能让你成为“香饽饽”
的
高级架构知识
,
每个笔记里面几乎都带有实战内容。很...
赞
踩
article
从
了
解到掌握
Spark
计算
框架
(一)
Spark
简介与基础概念_
spark
的哪个组件
提供
了
内存
计...
Spark
是一个基于
内存
的分布式
计算
框架
,最初由加州大学伯克利分校的 AMPLab 开发,后来捐赠给
了
Apache ...
赞
踩
article
Cesium
中
三维
热
力图
的实现思路_
cesium
三维
热
力图
...
4、将
热
力图
显示范围的多边形几何体进行三角细分(
Cesium
提供了三角细分相关的算法,PolygonGeometry.f...
赞
踩
article
PyTorch
中
RNN
、
LSTM
和
GRU
使用和理解_
torch
gru
...
PyTorch
中
RNN
,
LSTM
,
GRU
使用和理解。_
torch
gru
torch
gru
...
赞
踩
article
四种常用的标准
自定义
View
方法
(上)_
使用
过那些
自定义
view
...
感谢巨人的肩膀-------coder任玉刚+Tomcat的猫(一)继承
View
重写onDraw
方法
这种
方法
主要用于实...
赞
踩
article
java
实现的
经典
递归
算法
三例_
经典
递归
算法
java
...
一、写作此文的原因: 学过程序设计的朋友都知道,存在自调用的
算法
称作
递归
算法
。
递归
往往能给我们带来非常简洁非常直观...
赞
踩
article
深入理解
Kafka
副本
机制
_最小
副本
因子和
ack
=
all
...
一、
Kafka
集群
Kafka
使用 Zookeeper 来维护集群成员 (brokers) 的信息。每个 broker ...
赞
踩
article
鸿蒙
开发
实例:【
demo
-
搜索
历史记录
】
_
鸿蒙
demo
讲解...
HarmonyOs-
demo
-
搜索
历史记录
_
鸿蒙
demo
讲解
鸿蒙
demo
讲解  ...
赞
踩
article
最全
的
华为
面试题
-
java
学习...
华为
数据库
面试题
有2个表A,BA表中字段id以数字编码显示字段unitid是字段id
的
单位不过它也是数字显示形如:idu...
赞
踩
article
or
a
cle 19创建用户时出现“ORA-65096:
invalid
common
user
or
...
ORACLE 19创建用户命令_
or
a
65096
or
a
65096 ORACLE 19...
赞
踩
article
半
监督
图像
分割
-综述...
语义
分割
是计算机视觉中一个重要而热门的研究领域,其重点是根据
图像
中像素的语义对其进行分类。然而,
监督
式深度学习需要大量的...
赞
踩
article
最全
实验
案例
:
Linux
磁盘
挂载
(1),2024年最新不吃透都对不起自己_
挂载
硬盘
操作步骤
...
三.
实验
效果
磁盘
没扩容前
:
磁盘
扩容后
:
四.
实验
操作。_
挂载
硬盘
操作步骤
挂载
硬盘
操作步骤
...
赞
踩
article
flink
端到
端的
exactly
-
once
(精确一次)
_
flink
端到
端的
exactly
onc...
从source 到
flink
的
exactly
-
once
文章很多自己看。问题来源于群里一个人的提问。
flink
运算结果...
赞
踩
article
MediaPipe
- 02.
人脸
识别
_
delphi
编写
识别
人脸
程序
...
本系列文章介绍各类图像
识别
的使用方法,运用这些技巧采集更多的原始数据,训练我们的AI模型。本系列文章要有Python和O...
赞
踩
article
解决
服务器
80
端口
无法
连接的办法_
服务器
80
端口
无法
访问...
当您遇到
80
端口
无法
连接的问题时,您可以考虑检查云
服务器
的防火墙设置、网络连接和应用程序设置。如果您遵循上述步骤,您应该...
赞
踩
article
最新
AI
智能
系统
ChatGPT
网站
源码
V6.3版本,
GPTs
、
AI
绘画
、
AI
换脸、垫图混图+(Spa...
SparkAi
创作
系统
是基于
ChatGPT
进行开发的Ai智能问答
系统
和Midjourney
绘画
系统
,支持Open
AI
-G...
赞
踩
article
CPU
、
内存
和
人工智能
领域的
GPU
知识详解_
人工智能
计算
对 cpu频率的要求...
CPU
、
内存
和磁盘是服务器主要三大件,由于磁盘相对简单,本文重点讲解
CPU
、
内存
和目前在视频、
人工智能
领域成熟应用的GP...
赞
踩
article
自
定义
View
详解_
自
定义
view
定义
变量...
一、前言
自
定义
View
可能大家平常都会使用到,但是一般都是复制一个别人的代码,还没有过完全自己写的
自
定义
view
吧。自定...
赞
踩
article
VsCode
的
终端设置为
git
-
bash
环境
,
最新版
VsCode
设置_
vscode
git
bash
...
四轮技术面+一轮hr面结束
,
学习到了不少
,
面试也是一个学习检测自己
的
过程
,
面试前大概复习了 一周
的
时间
,
把以前
的
代码看了...
赞
踩
article
docker
打包
制作
镜像
#
centos7
-
java17
踩坑_
docker
打包
openjdk17
...
docker
打包
制作
镜像
#
centos7
-
java17
踩坑_
docker
打包
openjdk17
docker
打包
o...
赞
踩
相关标签
java
面试
开发语言
spark
大数据
分布式
hadoop
图形渲染
前端
rnn
pytorch
lstm
自定义
view
viewgroup
Layout
标准
string
disk
list
input
算法
harmonyos
鸿蒙开发