排序算法。

快速排序：QuickSort

选标准值，将比标准值小的放在其左侧，将比标准值大的放在其右侧，左右两部分分别重复以上操作

1.挖坑填补法

拆东墙补西墙

先把第一个数拿出来用temp储存 然后从最后面遍历 找到比temp小的放到第一个位置 然后再从前面第二个开始遍历找比temp大的放在后面的空位上 重复操作 直到end和begin在一块 然后再在temp两边分别重复操作


 

#include<stdio.h>int Find(int arr[],int nBegin,int nEnd)
{int temp = arr[nBegin];while(nBegin < nEnd){//从后向前找比标准值小的while(nEnd > nBegin){if(arr[nEnd] < temp){arr[nBegin] = arr[nEnd];nBegin++;break;}nEnd--;			 }//从前往后找比标准值大的while(nBegin < nEnd){if(arr[nBegin] > temp){arr[nEnd] = arr[nBegin];nEnd--;break;}nBegin++;} }//标准值放入arr[nBegin] = temp;return nBegin; 
}void QuickSort(int arr[],int nBegin,int nEnd)
{if(arr == NULL || nBegin >= nEnd)return;//确定标准值最终位置int nStandard;nStandard = Find(arr,nBegin,nEnd);//将数据分成两部分 分别重复以上操作QuickSort(arr,nBegin,nStandard-1);QuickSort(arr,nStandard+1,nEnd);
}void Print(int arr[],int length)
{if(arr == NULL || length <=0)return;int i;for(int i=0;i<length;i++){printf("%d ",arr[i]);}printf("\n");
}int main()
{int arr[] = {2,4,7,1,5,14,89,13,2};QuickSort(arr,0,sizeof(arr)/sizeof(arr[0])-1);Print(arr,sizeof(arr)/sizeof(arr[0]));return 0;
}

 2.区间分割法

small指向begin-1 begin从前向后遍历 遇见比end小的 就交换small+1与begin 最终将小于10的全放在一边

若 a = i++; 则等价于 a=i;i=i+1; 而 a = ++i; 则等价于 i=i+1;a=i;

#include<stdio.h>int Find(int arr[],int nBegin,int nEnd)
{int nSmall = nBegin-1;for(nBegin;nBegin < nEnd;nBegin++){if(arr[nBegin] < arr[nEnd]){if(++nSmall != nBegin){arr[nSmall] = arr[nSmall]^arr[nBegin];arr[nBegin] = arr[nSmall]^arr[nBegin];arr[nSmall] = arr[nSmall]^arr[nBegin];}}}//将标准值放入if(++nSmall != nEnd){arr[nSmall] = arr[nSmall]^arr[nEnd];arr[nEnd] = arr[nSmall]^arr[nEnd];arr[nSmall] = arr[nSmall]^arr[nEnd];}return nSmall; 
}void QuickSort(int arr[],int nBegin,int nEnd)
{if(arr == NULL || nBegin >= nEnd)return;//确定标准值最终位置int nStandard;nStandard = Find(arr,nBegin,nEnd);//将数据分成两部分 分别重复以上操作QuickSort(arr,nBegin,nStandard-1);QuickSort(arr,nStandard+1,nEnd);
}void Print(int arr[],int length)
{if(arr == NULL || length <=0)return;int i;for(int i=0;i<length;i++){printf("%d ",arr[i]);}printf("\n");
}int main()
{int arr[] = {2,4,7,1,5,14,89,13,2};QuickSort(arr,0,sizeof(arr)/sizeof(arr[0])-1);Print(arr,sizeof(arr)/sizeof(arr[0]));return 0;
}

MergeSort: 归并排序

将多个有序数组进行合并

 

#include<stdio.h>
#include<stdlib.h>void Merge(int arr[],int nBegin,int nEnd)
{int nBegin1 = nBegin;int nEnd1 = nBegin+(nEnd-nBegin)/2;int nBegin2 = nEnd1+1;int nEnd2 = nEnd;int *pTemp =NULL;pTemp = (int*)malloc(sizeof(int)*(nEnd-nBegin+1));int i=0;//遍历两个数组while(nBegin1 <= nEnd1 && nBegin2 <= nEnd2){if(arr[nBegin2] < arr[nBegin1]){pTemp[i++] = arr[nBegin2++];}else{pTemp[i++] = arr[nBegin1++];}}//将有剩余的数组元素放置while(nBegin1 <= nEnd1){pTemp[i++] = arr[nBegin1++];}while(nBegin2 <= nEnd2){pTemp[i++] = arr[nBegin2++];}//放回for(int i=0;i<nEnd-nBegin+1;i++){arr[nBegin+i] = pTemp[i];} free(pTemp);pTemp = NULL; 	
} void MergeSort(int arr[],int nBegin,int nEnd)
{if(arr == NULL || nBegin >= nEnd)return;//分割 int nMid = nBegin + (nEnd-nBegin)/2;MergeSort(arr,nBegin,nMid);MergeSort(arr,nMid+1,nEnd);//合并Merge(arr,nBegin,nEnd); 
} void Print(int arr[],int length)
{if(arr == NULL || length <=0)return;int i;for(int i=0;i<length;i++){printf("%d ",arr[i]);}printf("\n");
}int main()
{int arr[] = {2,4,7,1,5,14,89,13,2};MergeSort(arr,0,sizeof(arr)/sizeof(arr[0])-1);Print(arr,sizeof(arr)/sizeof(arr[0]));return 0;
}

冒泡排序：BubbleSort

相邻两个元素进行大小比较，如果前一个比后一个大，则二者发生交换

第一横：8和6比 8比6大 交换 8和3比 8比3大 交换 8和12比 没12大 不动 12和1比 比12大交换 12和7比 比12大交换 12没15大 不动

第二横；6和3比。。。。。。。

#include<stdio.h>void BubbleSort(int arr[],int length)
{if(arr == NULL || length<=0)return;int i;int j;for(int i=0;i<length-1;i++)              //总排n-1回 {for(int j=0;j<length-i-1;j++)        //每次固定一个大的，然后俩俩比较再-1 {if(arr[j] > arr[j+1]){arr[j] = arr[j]^arr[j+1];arr[j+1] = arr[j]^arr[j+1];arr[j] = arr[j]^arr[j+1];}}}
}void Print(int arr[],int length)
{if(arr == NULL || length <=0)return;int i;for(int i=0;i<length;i++){printf("%d ",arr[i]);}printf("\n");
}int main()
{int arr[] = {2,4,7,1,5,14,89,13,2};BubbleSort(arr,sizeof(arr)/sizeof(arr[0]));Print(arr,sizeof(arr)/sizeof(arr[0]));return 0;
}

堆排序：HeapSort

先创建一个初始堆，从下到上调节父亲节点，使得每个父亲节点的值比两个孩子大，最大值就窜到最上面了，接着交换第一和最后，拿掉最后面的最大值，重复调整堆顶，拿出每个最大值

调整操作 先把两个孩子比一下取最大值跟爹比 要比爹大就交换 然后交换下来的爹也得看看他的儿子比不比他大

#include<stdio.h>#define LEFT (2*nRootID+1)
#define RIGHT (2*nRootID+2)void Adjust(int arr[],int length,int nRootID)
{int MAX;for(MAX = LEFT;MAX < length;MAX = LEFT){//两个孩子if(RIGHT < length){if(arr[MAX] < arr[RIGHT]){MAX = RIGHT;}}//比较大小if(arr[nRootID] < arr[MAX]){//交换arr[nRootID] = arr[nRootID]^arr[MAX];arr[MAX] = arr[nRootID]^arr[MAX];arr[nRootID] = arr[nRootID]^arr[MAX];nRootID = MAX;}else{break;} }
}void HeapSort(int arr[],int length)
{if(arr == NULL || length <=0)return;//建初始堆int i;for(i = length/2-1;i>=0;i--){Adjust(arr,length,i);}//排序for(i = length-1;i>0;i--){//交换arr[0] = arr[i]^arr[0];arr[i] = arr[i]^arr[0];arr[0] = arr[i]^arr[0];//调整堆顶Adjust(arr,i,0);} 
}void Print(int arr[],int length)
{if(arr == NULL || length <=0)return;int i;for(int i=0;i<length;i++){printf("%d ",arr[i]);}printf("\n");
}int main()
{int arr[] = {2,4,7,1,5,14,89,13,2};HeapSort(arr,sizeof(arr)/sizeof(arr[0]));Print(arr,sizeof(arr)/sizeof(arr[0]));return 0;
}

桶排序：BucketSort

数据分组，各组之内进行排序

#include<stdio.h>
#include<stdlib.h>
#include<string.h>typedef struct node
{int value;struct node *pNext;
}Bucket;void Sort(Bucket *pHead)
{if(pHead == NULL || pHead->pNext == NULL)return;Bucket *pi = NULL;Bucket *pj = NULL;pi = pHead;while(pi->pNext != NULL)          // n-1趟 {pj = pHead;                   // 每次遍历从表头开始  while(pj->pNext != NULL)      // j和j的下一个进行比较 保证下一个有东西 {if(pj->value > pj->pNext->value){pj->value = pj->value^ pj->pNext->value;pj->pNext->value = pj->value^ pj->pNext->value;pj->value = pj->value^ pj->pNext->value;}pj = pj->pNext;           // j++ }pi = pi->pNext;               // i++ 减少趟数 }	
}void BucketSort(int arr[],int length)
{if(arr == NULL || length <=0)return;//1.最大值 最小值int nMin = arr[0];int nMax = arr[0];int i;for(int i=1;i<length;i++){if(arr[i] < nMin){nMin = arr[i];}if(arr[i] > nMax){nMax = arr[i];}}//2.位数int nCount = 1;int nNum = nMax;while(nNum){nNum/=10;nCount*=10;}nCount/=10;              //863变100  23变10 //3.表头int nMinIndex = nMin/nCount;int nMaxIndex = nMax/nCount;Bucket **pBucket = NULL;pBucket = (Bucket**)malloc(sizeof(Bucket*)*(nMaxIndex-nMinIndex+1));memset(pBucket,0,sizeof(Bucket*)*(nMaxIndex-nMinIndex+1));//4.元素入桶Bucket *pTemp = NULL;for(int i=0;i<length;i++){nNum = arr[i]/nCount-nMinIndex;pTemp = (Bucket*)malloc(sizeof(Bucket));pTemp->value = arr[i];pTemp->pNext = pBucket[nNum];pBucket[nNum] = pTemp; }//5.各桶之间元素排序for(int i=0;i<nMaxIndex-nMinIndex+1;i++){Sort(pBucket[i]);}//6.放回nNum=0;for(int i=0;i<nMaxIndex-nMinIndex+1;i++){pTemp = pBucket[i];while(pTemp){arr[nNum] = pTemp->value;nNum++;pTemp = pTemp->pNext;} }//7.释放Bucket *pDel = NULL;for(int i=0;i<nMaxIndex-nMinIndex+1;i++){pTemp = pBucket[i];while(pTemp){pDel = pTemp;pTemp = pTemp->pNext;free(pDel);pDel = NULL;}}free(pBucket);pBucket = NULL; 
}void Print(int arr[],int length)
{if(arr == NULL || length <=0)return;int i;for(int i=0;i<length;i++){printf("%d ",arr[i]);}printf("\n");
}int main()
{int arr[] = {201,405,743,165,589,140,989,193,288};BucketSort(arr,sizeof(arr)/sizeof(arr[0]));Print(arr,sizeof(arr)/sizeof(arr[0]));return 0;
}

选择排序：SelectSort

找最大值放到最后/最小值放在最前面

6和3比3大 6和9比没九大 max=9的下标 9和1比 然后一顿比 最大放在最后

#include<stdio.h>void SelectSort(int arr[],int length)
{if(arr == NULL || length<=0)return;int i;int j;int min;for(int i=0;i<length-1;i++){min=i;for(int j=i+1;j<length;j++){if(arr[j]<arr[min]){min=j;}}//最小值放入最前面if(min!= i){arr[i]=arr[i]^arr[min];arr[min]=arr[i]^arr[min];arr[i]=arr[i]^arr[min];} }
}void Print(int arr[],int length)
{if(arr == NULL || length <=0)return;int i;for(int i=0;i<length;i++){printf("%d ",arr[i]);}printf("\n");
}int main()
{int arr[] = {2,4,7,1,5,14,89,13,2};SelectSort(arr,sizeof(arr)/sizeof(arr[0]));Print(arr,sizeof(arr)/sizeof(arr[0]));return 0;
}

插入排序：InsertSort

将待排序数据分成两部分，一部分有序，一部分无序，将无序元素依次插入到有序中去完成排序

#include<stdio.h>void InsertSort(int arr[],int length)
{if(arr == NULL || length <=0)return;int i;    //无序的第一个int j;    //有序的最后一个int temp;for(int i=1;i<length;i++){j=i-1;temp=arr[i];  //无序的第一个元素while(j>=0 && temp<arr[j]){arr[j+1] = arr[j];j--;}arr[j+1]=temp; } 
}void Print(int arr[],int length)
{if(arr == NULL || length <=0)return;int i;for(int i=0;i<length;i++){printf("%d ",arr[i]);}printf("\n");
}int main()
{int arr[] = {2,4,7,1,5,14,89,13,2};InsertSort(arr,sizeof(arr)/sizeof(arr[0]));Print(arr,sizeof(arr)/sizeof(arr[0]));return 0;
}

希尔排序：ShellSort

将数据分组，各组之内插入排序，比原有插入排序更快，适合大量数据，不常用。

 

计数排序：CountingSort

核心思想：基于非比较的排序

1.找最大值和最小值

2.计数

3.排序

#include<stdio.h>
#include<stdlib.h>
#include<string.h>   //memsetvoid CountingSort(int arr[],int length)
{if(arr == NULL || length <=0)return;int i;int min = arr[0];int max = arr[0];//最大值最小值查找for(int i=1;i<length;i++){if(arr[i]<min){min=arr[i];}if(arr[i]>max){max=arr[i];} }//计数空间int *pCount=NULL;pCount=(int*)malloc(sizeof(int)*(max-min+1));memset(pCount,0,sizeof(int)*(max-min+1));//计数for(i=0;i<length;i++){pCount[arr[i]-min]++;}//名次for(int i=1;i<max-min+1;i++){pCount[i]=pCount[i]+pCount[i-1];}//排序int *pNew = (int*)malloc(sizeof(int)*length);for(i=length-1;i>=0;i--){pNew[pCount[arr[i]-min]-1]=arr[i];pCount[arr[i]-min]--;}//放回原数组for(int i=0;i<length;i++){arr[i]=pNew[i];}free(pNew);pNew=NULL;free(pCount);pCount=NULL; 
}
void Print(int arr[],int length)
{if(arr == NULL || length <=0)return;int i;for(int i=0;i<length;i++){printf("%d ",arr[i]);}printf("\n");
}int main()
{int arr[] = {2,4,7,1,5,14,89,13,2};CountingSort(arr,sizeof(arr)/sizeof(arr[0]));Print(arr,sizeof(arr)/sizeof(arr[0]));return 0;
}

基数排序：RadixSort

LSD：低位优先

MSD：高位优先

#include<stdio.h>
#include<stdlib.h>
#include<string.h>typedef struct node
{int value;struct node *pNext;
}Radix;void RadixSort(int arr[],int length)
{if(arr == NULL || length <= 0)return;//找最大值int nMax = arr[0];int i;for(int i=1;i<length;i++) {if(arr[i] > nMax){nMax = arr[i];}}//计算最大值位数int nCount = 0;while(nMax){nMax/=10;nCount++;}//按位处理int nLoopTimes;int nbase = 1;//表头 Radix **pRadix = NULL;pRadix = (Radix**)malloc(sizeof(Radix*)*10);memset(pRadix,0,sizeof(Radix*)*10);for(nLoopTimes = 1;nLoopTimes<=nCount;nLoopTimes++){i = nLoopTimes;while(i>1){nbase*=10;i--;}//数据入组Radix *pTemp = NULL;for(i = 0;i<length;i++){pTemp = (Radix*)malloc(sizeof(Radix));pTemp->value = arr[i];pTemp->pNext = NULL;//尾添加if(pRadix[arr[i]/nbase%10] == NULL){pRadix[arr[i]/nbase%10] = pTemp;}else{Radix *pNode = pRadix[arr[i]/nbase%10];while(pNode->pNext){pNode = pNode->pNext;}pNode->pNext = pTemp;}}//放回 int j=0;for(i=0;i<10;i++){pTemp = pRadix[i];while(pTemp){arr[j]=pTemp->value;pTemp = pTemp->pNext;j++;}} //释放Radix *pDel = NULL;for(int i=0;i<10;i++){pTemp = pRadix[i];while(pTemp){pDel = pTemp;pTemp = pTemp->pNext;free(pDel);pDel = NULL;}}//清空memset(pRadix,0,sizeof(Radix*)*10); 	 } free(pRadix);pRadix = NULL;
}void Print(int arr[],int length)
{if(arr == NULL || length <=0)return;int i;for(int i=0;i<length;i++){printf("%d ",arr[i]);}printf("\n");
}int main()
{int arr[] = {53, 3, 542, 748, 14, 214, 154, 63, 616};RadixSort(arr,sizeof(arr)/sizeof(arr[0]));Print(arr,sizeof(arr)/sizeof(arr[0]));return 0;
}

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

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

相关文章

代码随想录第36天|动态规划

代码随想录第36天|动态规划

62. 不同路径 补充: 对二维数组的操作 dp[j][i] 表示到 j,i 有多少种路径递推公式: dp[j][i] dp[j - 1][i] dp[j][i - 1]初始化: dp[0][i] 和 dp[j][0] 都只有1种情况遍历顺序: 由于dp[j][i] 由 上和左的元素推导, 所以采用从左到右、从上到下的遍历顺序 class Solution {…
阅读更多...
【PL理论深化】(9) Ocaml 语言：自定义类型 | 异常处理 | 模块

【PL理论深化】(9) Ocaml 语言：自定义类型 | 异常处理 | 模块

&#x1f4ac; 写在前面&#xff1a;本章我们将继续介绍 OCaml 的基本特性&#xff0c;自定义类型、异常处理和模块。掌握了这些内容后&#xff0c;编写基本程序应该不会有太大困难。接下来的两节将学习函数式编程中常用的两种编程风格 —— 递归函数和高阶函数。 目录 0x00 …
阅读更多...
python CSSE7030

python CSSE7030

1 Introduction In this assignment, you will implement a (heavily) simplified version of the video game ”Into The Breach”. In this game players defend a set of civilian buildings from giant monsters. In order to achieve this goal, the player commands a s…
阅读更多...
基于51单片机的银行排队呼叫系统设计

基于51单片机的银行排队呼叫系统设计

一.硬件方案 本系统是以排队抽号顺序为核心&#xff0c;客户利用客户端抽号&#xff0c;工作人员利用叫号端叫号&#xff1b;通过显示器及时显示当前所叫号数&#xff0c;客户及时了解排队信息&#xff0c;通过合理的程序结构来执行排队抽号。电路主要由51单片机最小系统LCD12…
阅读更多...
unity使用XR插件开发SteamVR项目，异常问题解决方法

unity使用XR插件开发SteamVR项目，异常问题解决方法

一、unity使用XR插件开发SteamVR项目&#xff0c;运行后相机高度异常问题解决方法如下操作 &#xff08;一&#xff09;、开发环境 1、Unity 2021.3.15f 2、XR Interaction Toolkit Version 2.5.2 &#xff08;com.unity.xr.interaction.toolkit&#xff09; 3、OpenXR Pl…
阅读更多...
ArmSoM-Sige7/5/1 和树莓派5规格比较

ArmSoM-Sige7/5/1 和树莓派5规格比较

引言 在当今快速发展的嵌入式系统领域&#xff0c;选择一款性能强大、功能丰富的开发板对于项目的成功至关重要。本文将介绍并比较 Sige7、Sige5、Raspberry Pi 5 和 Sige1 这四款开发板的关键规格和特性&#xff0c;帮助开发者和爱好者选择最适合其需求的平台。 ArmSoM-Sige…
阅读更多...
智慧校园-缴费管理系统总体概述

智慧校园-缴费管理系统总体概述

在构建现代化教育环境的过程中&#xff0c;智慧校园缴费管理系统脱颖而出&#xff0c;成为提升校园财务管理效率与服务质量的关键一环。缴费管理系统需要精心设计&#xff0c;通过科技力量&#xff0c;让原本繁琐的缴费流程变得简单快捷&#xff0c;同时增强家校之间的互动与信…
阅读更多...
postman教程-22-Newman结合Jenkins执行自动化测试

postman教程-22-Newman结合Jenkins执行自动化测试

上一小节我们学习了Postman Newman运行集合生成测试报告的方法&#xff0c;本小节我们讲解一下Postman Newman结合Jenkins执行自动化测试的方法。 在软件开发过程中&#xff0c;持续集成&#xff08;CI&#xff09;是一种实践&#xff0c;旨在通过自动化的测试和构建过程来频繁…
阅读更多...
Transformers 安装与基本使用

Transformers 安装与基本使用

文章目录 Github文档推荐文章简介安装官方示例中文情感分析模型分词器 Tokenizer填充 Padding截断 Truncation google-t5/t5-small使用脚本进行训练Pytorch 机器翻译数据集下载数据集格式转换 Github https://github.com/huggingface/transformers 文档 https://huggingface…
阅读更多...
【Sklearn-LR驯化】一文搞懂分类基石模型-逻辑回归使用总结

【Sklearn-LR驯化】一文搞懂分类基石模型-逻辑回归使用总结

【Sklearn-驯化】一文搞懂分类基石模型-逻辑回归使用总结 本次修炼方法请往下查看 &#x1f308; 欢迎莅临我的个人主页 &#x1f448;这里是我工作、学习、实践 IT领域、真诚分享 踩坑集合&#xff0c;智慧小天地&#xff01; &#x1f387; 免费获取相关内容文档关注&#xf…
阅读更多...
Transformer教程之Encoder-Decoder架构

Transformer教程之Encoder-Decoder架构

在当今的自然语言处理&#xff08;NLP&#xff09;领域&#xff0c;Transformer已经成为不可或缺的模型。它以其高效的并行计算和卓越的性能在多个任务中占据了主导地位。在这篇文章中&#xff0c;我们将深入探讨Transformer的核心——Encoder-Decoder架构&#xff0c;帮助大家…
阅读更多...
设计模式原则——接口隔离原则

设计模式原则——接口隔离原则

设计模式原则 设计模式示例代码库地址&#xff1a; https://gitee.com/Jasonpupil/designPatterns 接口隔离原则 要求程序员尽量将臃肿庞大的接口拆分为更小的和更具体的接口&#xff0c;让接口中只包含客户感兴趣的方法接口隔离原则的目标是降低类或模块之间的耦合度&…
阅读更多...
STM32将外部SDRAM空间作为系统堆(Heap)空间

STM32将外部SDRAM空间作为系统堆(Heap)空间

概述 stm32可以外扩很大的sram&#xff0c;常见外部sram的初始化函数一般是c语言写的&#xff0c;默认写在main函数里面。stm32初始化首先进入汇编代码startup_stm32f429xx.s&#xff0c;在汇编代码中Reset_Handler&#xff08;复位中断服务程序&#xff09;里面先调用了Syste…
阅读更多...
【Python机器学习】自动化特征选择——迭代特征选择

【Python机器学习】自动化特征选择——迭代特征选择

在单变量测试中&#xff0c;没有使用模型&#xff1b;在基于模型的选择中&#xff0c;使用单个模型来选择特征。而在迭代特征选择中&#xff0c;将会构造一系列模型&#xff0c;每个模型都使用不同数量的特征。有两种基本方法&#xff1a; 1、开始时没有特征&#xff0c;然后逐…
阅读更多...
Django使用

Django使用

一、安装Django 可以在创建好的虚拟环境中下载包 pip install Django3.2.20 -i https://pypi.tuna.tsinghua.edu.cn/simple 查看对应的下载好的内容 1、在Lib的site-packages第三方包里&#xff1a;这就是django框架源码 2、在scripts中有个 这是个工具&#xff0c;帮助创建d…
阅读更多...
Java nio 的线程通信机制线程通信Pipe

Java nio 的线程通信机制线程通信Pipe

Java的Pipe是一种新的线程通信机制&#xff0c;传统的线程通信可以是通过共享内存的方式&#xff0c;socket等方式&#xff0c;而Pipe是通过Java NIO 通信的方式实现共享内存&#xff0c;优点类似于go语言的管道 先上代码 public static void main(String[] args) throws IOEx…
阅读更多...
Java网络编程（JavaWeb的基础）

Java网络编程（JavaWeb的基础）

Java网络编程&#xff08;JavaWeb的基础&#xff09; 文章目录 Java网络编程&#xff08;JavaWeb的基础&#xff09;前言一、网络编程概述1.1 软件架构&网络基础1.2 网络通信要素:IP/端口/通信协议1.3 传输层协议:tcp/udp 二、网络编程API2.1 InetAddress类2.2 Socket类&am…
阅读更多...
DELL：利用大语言模型（LLM）生成评论与解释，革新虚假信息检测

DELL：利用大语言模型（LLM）生成评论与解释，革新虚假信息检测

ACL 2024 DELL: Generating Reactions and Explanations for LLM-Based Misinformation Detection https://arxiv.org/abs/2402.10426https://arxiv.org/abs/2402.10426 1.概述 大型语言模型（LLM）虽在诸多领域显示出色性能，但在直接应用于新闻真实性鉴别时，面临两大核心挑…
阅读更多...
uboot基本使用网络命令和从服务器端下载linux内核启动

uboot基本使用网络命令和从服务器端下载linux内核启动

网络命令ip地址设置: setenv gmac_debug 0; setenv mdio_intf rgmii; setenv bootdelay 1; setenv ethaddr 00:xxxx:81:70; // mac地址 setenv ipaddr xxx; //开发板 IP 地址 setenv netmask 255.255.255.0; setenv gatewayip xxx.1; setenv serverip xxxx; //服…
阅读更多...
潮玩手办盲盒前端项目模版的技术探索与应用案例

潮玩手办盲盒前端项目模版的技术探索与应用案例

一、引言 在数字化时代&#xff0c;随着消费者对个性化和艺术化产品的需求日益增长&#xff0c;潮玩手办和盲盒市场逐渐崭露头角。为了满足这一市场需求&#xff0c;前端技术团队需要构建一个功能丰富、用户友好的在线平台。本文旨在探讨潮玩手办盲盒前端项目模版的技术实现&a…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发