国民小跟班

算法设计与分析————找出数组中最大值和次大值的14钟方法

1. 一次循环查找

#include
//找到最大的元素和次大的元素 
void find(int a[],int b[])
{
	int max1=a[0];
	int max2=-1000,t;
	for(int i=0;i<6;i++)
	{
		if(a[i]>max2)
		   if(a[i]>max1)
	           max2=a[i];   
           else
           {
		  	 max2=max1;
		  	 max1=a[i];
			           }
	
	}
	b[0]=max1;
	b[1]=max2;
}


int main()
{
	int b[2]={0,0};
	int a[]={2,5,1,4,6,3}; 
	find(a,b);
	printf("最大值为%d",b[0]);
	printf("\n");
	printf("次大值为%d",b[1]);
 }

2.两次循环查找

#include
//找到最大的元素和次大的元素 
void find(int a[],int b[])
{
	int max=a[0];
	int max1=0;
    for(int i=0;i<6;i++)
    {
    	if(a[i]>max)
           max=a[i];
	}
	for(int i=0;i<6;i++)
	{
		if(a[i]<max&&a[i]>max1)
		   max1=a[i];
	}
	b[0]=max;
	b[1]=max1;
}


int main()
{
	int b[2]={0,0};
	int a[]={2,5,1,4,6,3}; 
	find(a,b);
	printf("最大值为%d",b[0]);
	printf("\n");
	printf("次大值为%d",b[1]);
 }

3.减1排序

#include

void sort(int a[],int n)
{
	int p;
	int k=0;
	int b[n],c[n];
	for(int i=0;i<n;i++)
	 {
	   b[i]=a[i];
	   c[i]=a[i];
     }
     printf("\n");

while(k<n)
{         
     for(int i=0;i<n;i++)
	 {
	    b[i]=b[i]-1;
	    if(b[i]==0)
	 	  a[k++]=c[i];
	 }	   
}
}

int main()
{
	int a[]={2,5,1,4,6,3};
	int n=sizeof(a)/sizeof(a[0]);
	printf("排序前，数组为");
	for(int i=0;i<6;i++) 
	printf("%d",a[i]);
	sort(a,n);
	printf("排序后，数组为");
	for(int i=0;i<6;i++)
	printf("%d",a[i]);
	printf("\n");
	printf("最大值为%d",a[n-1]);
	printf("\n");
	printf("次大值为%d",a[n-2]);
	return 0;
}

4.简单选择排序

#include

void sort(int a[],int n)
{
	int t;
	for(int i=0;i<n-1;i++)
	{
	   for(int j=i+1;j<n;j++)
	   {
	   	   if(a[j]>a[i])
	    {
	   	      t=a[j];	
	   		  a[j]=a[i];
	   		  a[i]=t;
		      }
	   } 
    }
}



int main()
{
	int a[]={2,5,1,4,6,3}; 
	sort(a,6);
	printf("最大值为%d",a[0]);
	printf("\n");
	printf("次大值为%d",a[1]);
 }

5.冒泡排序

#include

void sort(int a[],int n)
{
	int t;
    for(int i=0;i<n;i++)
        for(int j=0;j<n-i-1;j++) 
		  	if(a[j+1]>a[j])
		  	{
		  	     t=a[j];
		  	     a[j]=a[j+1];
		  	     a[j+1]=t;
			}
}

int main()
{
	int a[]={2,5,1,4,6,3}; 
	sort(a,6);
	printf("数组为");
	for(int i=0;i<6;i++)
	printf("%d",a[i]);
	printf("\n");
	printf("最大值为%d",a[0]);
	printf("\n");
	printf("次大值为%d",a[1]);
 }

6.直接插入排序

#include

void sort(int a[],int n)
{
	int i,j;
    for(i=2;i<n;i++)
	{
		a[0]=a[i];
		j=i-1;
		while(a[0]>a[j])
		{
		   a[j+1]=a[j];
		    j--;
		}
		a[j+1]=a[0];
	 } 
}

int main()
{
	int a[]={-100,2,5,1,4,6,3}; 
	printf("排序前数组为");
	for(int i=1;i<=6;i++)
	printf("%d",a[i]);
	printf("\n");
	sort(a,7);
	printf("排序后数组为");
	for(int i=1;i<=6;i++)
	printf("%d",a[i]);
	printf("\n");
	printf("最大值为%d",a[1]);
	printf("\n");
	printf("次大值为%d",a[2]);
 }

7.折半插入排序

#include

void sort(int r[],int length)
{
  int x;
  int mid;
  for(int i=2;i<=length;i++)//从第2个值开始，不断插入 
  {
   	x=r[i];//将插入值存放在x中 
	int low=1;
	int high=i-1;//high表示上一次数组的最后一个位置的值 
	while(low<=high) 
	{
		mid=(low+high)/2; 
		if(x<r[mid])  //比较与中间值的大小关系 
		  high=mid-1;
		else
		  low=mid+1;
	}
	for(int j=i-1;j>=low;j--)//将所有的后面的值向前挪 
	   r[j+1]=r[j]; 
	r[low]=x;//在low处放入数之 
  }
}

int main()
{
	int a[]={0,2,5,1,4,6,3};
	int n=sizeof(a)/sizeof(a[0]);
	printf("排序前数组为");
	for(int i=1;i<7;i++)
	printf("%d ",a[i]);
	sort(a,n);
	printf("\n");
	printf("排序后数组为");
	for(int i=1;i<7;i++)
	printf("%d ",a[i]);
	printf("\n");
	printf("最大值为%d",a[n-1]);
	printf("\n");
	printf("次大值为%d",a[n-2]);
	return 0;
 }

8.快速排序

//快速排序 
#include
#include 
 
int part(int a[],int s,int t) 
{
	int *b;
    int i,j;
    int k=s;
	int mid=a[s];	
    i=s;
  	j=t;
 	b=(int*)malloc((t-s+1)*sizeof(int));
 	for(int k=s+1;k<=t;k++)
 	{
 	    if(a[k]<mid)
		  b[j--]=a[k];
	    else
	      b[i++]=a[k];
 	}
 	b[i]=mid;
 	for(int v=s;v<=t;v++)
 	    a[v]=b[v];
 	free(b);
 	return i;
}
 
void sort(int a[],int s,int t)
{
	int i;
	if(s<t)
	{
	   i=part(a,s,t);
       sort(a,s,i-1);
       sort(a,i+1,t);
    } 
}


int main()
{
	int a[]={-100,2,5,1,4,6,3}; 
	printf("排序前数组为");
	for(int i=1;i<=6;i++)
	printf("%d ",a[i]);
	printf("\n");
	sort(a,1,6);
	printf("排序后数组为");
	for(int i=1;i<=6;i++)
	printf("%d ",a[i]);
	printf("\n");
	printf("最大值为%d",a[1]);
	printf("\n");
	printf("次大值为%d",a[2]);
 }

9.归并排序

//归并排序
#include
#include

void merge(int a[],int low,int mid,int high)
{
	int i=low;
	int j=mid+1;
	int k=0;
	int *temp;
	temp=(int *)malloc((high-low+1)*sizeof(int));
	while(i<=mid&&j<=high)
	{
	   if(a[i]<a[j]) 
	   	 temp[k++]=a[i++];
	   else
	   	 temp[k++]=a[j++];
	}
	
	 while(i<=mid)
	 	temp[k++]=a[i++]; 
	 	
	 while(j<=high)
	 	temp[k++]=a[j++];
	 	
	for(int i=low,k=0;i<=high;i++)
	   a[i]=temp[k++];
	   	
	free(temp);
}


void sort(int a[],int low,int high)
{
	int mid;
	if(low<high)
	{
		mid=(low+high)/2;
		sort(a,low,mid);
		sort(a,mid+1,high);
		merge(a,low,mid,high);
	}
}



int main()
{
	int a[]={-100,2,5,1,4,6,3}; 
	printf("排序前数组为");
	for(int i=1;i<=6;i++)
	printf("%d ",a[i]);
	printf("\n");
	sort(a,1,6);
	printf("排序后数组为");
	for(int i=1;i<=6;i++)
	printf("%d ",a[i]);
	printf("\n");
	printf("最大值为%d",a[6]);
	printf("\n");
	printf("次大值为%d",a[5]);
 }

10.希尔排序

#include

void sort(int a[],int n)
{
	 int i,j,gap,temp,k;
	 printf("%d",n);
     for(gap=n/2;gap>=1;gap/=2)	
	 {
	    for(i=0;i<gap;i++) 	
	 	{
	 	   for(j=i+gap;j<n;j+=gap)	
	 		{
	 			if(a[j-gap]>a[j])
	 		   {
	 		    temp=a[j];	
	 			for(k=j-gap;k>=0&&a[k]>temp;k-=gap)
	 			    a[k+gap]=a[k];
	 			a[k+gap]=temp;
	        	}
			 }
		 }
	 }
} 


int main()
{
	int a[]={2,5,1,4,6,3};
	int n=sizeof(a)/sizeof(a[0]);
	sort(a,n);
	printf("数组为");
	for(int i=0;i<6;i++)
	printf("%d",a[i]);
	printf("\n");
	printf("最大值为%d",a[n-1]);
	printf("\n");
	printf("次大值为%d",a[n-2]);
	return 0;
 }

11.堆排序

#include

void head_adjust(int* arr,int s,int m) // 一个交换的过程 
{
	int temp=arr[s];  //将要交换的值存起来 
	for(int j=2*s+1;j<=m;j=2*j+1) //挑出当前层的最大值 
	{
		if(j<m&&arr[j]<arr[j+1])//选择两个中较大的                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
		     ++j;            //左边小的话选右边 
		if(temp>=arr[j])//如果有一个值超过了arr[j],两者进行一次交换 
		    break;
		arr[s]=arr[j];//交换1 
		s=j;   //记录j的小标 
	}
	arr[s]=temp; //交换2
 } 
 
void  swap(int a,int b)  //将两个数字进行交换 
{	
    int t;
     t=a;
     a=b;
     b=t;
} 
 
 void sort(int *arr,int len)  
 {
 	for(int i=(len-1)/2;i>=0;i--)//建立一个大顶堆 //保证n-1层满足即可 
 	{
 		head_adjust(arr,i,len-1); //
	 }
 	for(int i=len-1;i>0;i--)//进行堆排序 
 	{
 		swap(arr[0],arr[i]);//每次与将其中的一个值与a[0]交换，破坏顶堆 
 		head_adjust(arr,0,i-1);//堆顶元素和堆底元素交换，使用的大顶堆 
	 }
 }
 
 int main()
{
	int a[]={2,5,1,4,6,3};
	int n=sizeof(a)/sizeof(a[0]);
	printf("排序前数组为");
	for(int i=0;i<6;i++)
	printf("%d ",a[i]);
	sort(a,n);
	printf("\n");
	printf("排序后数组为");
	for(int i=0;i<6;i++)
	printf("%d ",a[i]);
	printf("\n");
	printf("最大值为%d",a[0]);
	printf("\n");
	printf("次大值为%d",a[1]);
	return 0;
 }

12.桶排序

//快速排序 
#include
#define N  100 

void  sort(int a[],int n)
{
   int k=0; 
   int bucket[N];
   
   for(int i=0;i<N;i++)
      bucket[i]=0;
      
    for(int i=0;i<n;i++)
      bucket[a[i]]=1;
      
    for(int i=0;i<N;i++)
      for(int j=0;j<bucket[i];j++)
           a[k++]=i;         
}
        
int main()
{
	int a[]={2,5,1,4,6,3}; 
	int n=sizeof(a)/sizeof(a[0]);
	printf("排序前数组为");
	for(int i=0;i<6;i++)
	printf("%d ",a[i]);
	printf("\n");
	
	sort(a,n);
	
	printf("排序后数组为");
	for(int i=0;i<6;i++)
	printf("%d ",a[i]);
	printf("\n");
	
	printf("最大值为%d",a[n-1]);
	printf("\n");
	printf("次大值为%d",a[n-2]);
 }

13.计数排序

#include


void sort(int a[],int n)
{
    int max=a[0],min=a[0];	
	for(int i=0;i<n;i++) //挑选最大，最小值 
	{
	   if(a[i]>max)
	    {
	     max=a[i];	
		 }
		if(a[i]<min)
		{
		 min=a[i];
		 } 
	}
	
   int k=max-min+1;
   int c[k]={0};  //创建计数数组 
   
   
   for(int i=0;i<n;i++)  //计数 
   {
   	 c[a[i]-min]+=1;
   }
   
     
   int j=0;
   for(int i=0;i<k;i++)
   {
   	  while(c[i]>0)
   	  {
   	  	a[j]=i+min;
   	  	j++;
   	  	c[i]--;
	  }  	
   }
}

int main()
{
	int a[]={2,5,1,4,6,3}; 
	int n=sizeof(a)/sizeof(a[0]);
	printf("排序前数组为");
	for(int i=0;i<6;i++)
	printf("%d ",a[i]);
	printf("\n");
	
	sort(a,n);
	
	printf("排序后数组为");
	for(int i=0;i<6;i++)
	printf("%d ",a[i]);
	printf("\n");
	
	printf("最大值为%d",a[n-1]);
	printf("\n");
	printf("次大值为%d",a[n-2]);
 }

14.基数排序

#include
#include

void RadixCountSort(int *index,int *a,int len)
{
	int i;
	int *count=(int *)malloc(sizeof(int)*10);
	
	for(i=0;i<10;i++)  //计数数组为0 
	  count[i]=0;
	  
	for(i=0;i<len;i++)   //记录索引对应标记 
	    count[index[i]]++;  
	    
	for(i=1;i<10;i++)         //将数字累加 
	    count[i]=count[i]+count[i-1];
	
	int *sort=(int *)malloc(sizeof(int)*len);  //创建一个临时数组空间 
	
	for(i=len-1;i>=0;i--)        //倒序输出 
	{
		count[index[i]]--;        //对应位置-1 
		sort[count[index[i]]]=a[i];   //放入对应的数组 
	}
	//index[i]值-----sort----count[]下标   
	
	
	for(i=0;i<len;i++)
	  a[i]=sort[i];
	  
	free(sort);
	free(count);
 } 
 
 void RadixSort(int *a,int len)
 {
 	int i,x=1;
 	int tmp=1;
 	int *radix=(int *)malloc(sizeof(int)*len);//创建一个单个位数的数组 （同为个位，十位，或百位） 
 	
 	while(x) //当x不等于0时 
 	{
 		tmp=tmp*10;
 		x=0;
 		
 		for(i=0;i<len;i++)
 		{                           //举例当a[i]=123       
 			radix[i]=a[i]%tmp;  //           3    23    123   123
 			radix[i]=radix[i]/(tmp/10); //   3     2     1     0
 			if(a[i]/tmp>0)//如果对应还存在不为0的商，继续循环 
 			{
 				x=1;
			 }
		 }
		 RadixCountSort(radix,a,len);//是数组a发生变化，本轮的a将会排好 
      //同位数的比较，当a排好之后，位数相同的就排好了 
	 // 不位数的比较，位数不同的以0做区分 
	 }
	 free(radix);
 }
 
 int main()
 {
 	int i,len;
 	int a[]={2,5,1,4,6,3}; 
 	len=sizeof(a)/sizeof(int);
 	printf("排序前，数组为"); 
 	for(i=0;i<len;i++)
 		printf("%d ",a[i]);
 		
 	printf("\n");
 	RadixSort(a,len);
 	
 	printf("排序后，数组为"); 
 	for(i=0;i<len;i++)
 		printf("%d ",a[i]);
 		
    printf("\n");
	printf("最大值为%d",a[len-1]);
	printf("\n");
	printf("次大值为%d",a[len-2]);
	return 0;	
 }

你可能感兴趣的:(#,2.算法分析与设计,排序,c语言,课后习题,算法设计与分析)

C语言：强符号和弱符号 Dola_Pan C语言 c语言 linux 算法
我们在编写代码的过程中经常会遇到一种叫做符号重复定义（MultipleDefinition）的错误，这是因为在多个源文件中定义了名字相同的全局变量，并且都将它们初始化了。例如，在a.c中定义了全局变量global：intglobal=10;在b.c中又对global进行了定义：intglobal=20;那么在链接时就会出现下面的错误：b.o:multipledefinitionof`global'
deepseek手把手教你怎么接入WPS Uyker wps 人工智能
DeepSeek接入WPS主要有以下两种方法：利用WPS官方内置功能接入1.升级WPS：将WPS升级至2025新春版（12.8.0及以上）。2.打开功能入口：在文字/表格文档界面右上角点击「智能助手」图标，或使用快捷键Ctrl+J调出AI侧边栏。3.账户绑定：首次使用需登录WPS账号，然后完成DeepSeekAPI密钥绑定。密钥获取路径为：DeepSeek官网>开发者中心>创建APIKey。4.智
计算机一级wpsoffice知识点,计算机一级考试WPSOffice考试大纲 weixin_39747293
◆基本要求1.具有使用微型计算机的基础知识(包括计算机病毒的防治常识)。2.了解微型计算机系统的组成和各组成部分的功能。3.了解操作系统的基本功能和作用，掌握Windows的基本操作和应用。4.了解文字处理的基本知识，掌握文字处理软件“金山文字2003”的基本操作和应用，熟练掌握一种汉字(键盘)输入方法。5.了解电子表格软件的基本知识，掌握电子表格软件“金山表格2003”的基本操作和应用。6.了解
Java 实现拖拽列表更新排序架构师成长进阶空间 Java spring cloud spring boot java 后端
拖拽列表更新排序，接口提供给前端这个功能主要是需要的算法逻辑很多图解：如在前端页面上想把id=5拖拽到id=3上拖拽之后的效果：解析图例：代码示例：DevToCoding｜Java面试指南、学习笔记/***拖拽数据更新排序*@paramcurrentId当前数据id*@paramtargetId目标数据id*@return*/@RequestMapping("/sort/{currentId}/{
微信小程序图片拖拽排序组件：wx-drag-img 安装与使用指南庞眉杨Will
微信小程序图片拖拽排序组件：wx-drag-img安装与使用指南项目地址:https://gitcode.com/gh_mirrors/wx/wx-drag-img项目概述wx-drag-img是一个专为微信小程序设计的图片拖拽排序组件。它允许用户通过原生微信小程序语法轻松实现图片列表的拖动重排功能，简化了开发者在微信小程序中集成此类交互的需求。目录结构及介绍仓库的主要目录结构如下：.├──exa
SAP-ABAP：SAP中REPORT程序和online程序的区别对比爱喝水的鱼丶 SAP-ABAP开发基础详解 ABAP开发之必须知道的 SAP ABAP ERP 企业应用开发运维
在SAP中，REPORT程序和Online程序（通常指Dialog程序）是两种常见的ABAP程序类型，它们在用途、结构和用户交互方式上有显著区别。以下是它们的详细对比：1.用途REPORT程序Online程序主要用于数据查询、报表生成和批量数据处理。主要用于交互式操作，如数据输入、修改和实时处理。通常用于后台或批处理任务，用户交互较少。强调用户与系统的实时交互，通常用于事务处理。2.用户交互REP
Redis之父学生时代发现的ping漏洞的源码分析
Redis的作者SalvatoreSanfilippo（网名antirez）在意大利西西里岛长大，虽然从小就接触计算机，也有一些编程经验，但在大学期间却选择了建筑学院，可能当时并没有打算走职业程序员的道路吧。然而antirez应该就属于老天爷赏饭的那类人，据说仅仅因为错把显卡买成了网卡，商家又不肯退货，他就放下游戏，拿起了C语言的教材。不久之后，antirez发现了一个ping的漏洞，非root用
【WPS&Office】汇总 YvesHe 【Office】WPS Office
写在前面PPT篇幻灯片母版通过母版功能统一幻灯片的样式、字体、颜色等，提高整体一致性。统一设置模板样式字体安装查找到字体并安装。在WPSPPT（WPS演示）中，以下是最常用的十个功能，能够帮助用户高效制作和编辑演示文稿：1.幻灯片模板与主题提供多种内置模板和主题，用户可以快速选择合适的风格，提高幻灯片的美观度和专业性。2.幻灯片版式与布局可调整幻灯片的布局，如标题、文本、图片和图表的排列方式，以适
opencv全面详解教程听忆. 机器学习深度学习计算机视觉人工智能
opencv全面详解教程1.OpenCV简介2.安装OpenCV2.1使用pip安装（适用于Python）2.2通过conda安装2.3从源码编译（高级）3.OpenCV基本操作3.1读取和显示图像3.2保存图像3.3视频处理4.图像处理操作4.1调整大小和裁剪4.2颜色空间转换4.3图像平滑（滤波）4.4边缘检测5.形态学操作6.特征检测与匹配6.1角点检测（Harris）6.2SIFT、SUR
计算机控制面板都打不开怎么办,控制面板打不开怎么办？控制面板打开办法大全... weixin_39982017 计算机控制面板都打不开怎么办
控制面板真的很好用，在我们电脑卡机的转态下，打开控制面板一键关掉所有应用程序，不要太方便哦。还有的小伙伴喜欢用控制面板打开关闭程序呢。不过控制面板打不开怎么办？贤集网的小编今天就给大家带来了控制面板打开办法大全，里面准保有解决办法。控制面板打不开怎么办1.系统与应用冲突了这种情况在刚刚下载了新应用下比较常见，仔细回想下，问题出在什么时候？是不是刚刚下载过什么应用程序的？删除掉就好了。2.设置了禁止
3 ＞数据结构与算法栈与队列 irisart 数据结构与算法（C语言考研期末复习版）c语言数据结构
概览本节总结了栈和队列的基本概念和用法，另外附上栈与队列的基本操作代码（C语言版）。本节适合有C语言基础的初学者、期末复习、考研等方面的用途。栈只允许在一端插入和删除操作的线性表。代码如下特点：先进后出模式（LIFO），只能在栈顶操作。什么是卡特兰数：有n个元素进栈（顺序可以不同），出栈元素不同的排列个数为1n+1C2nn\frac{1}{n+1}C^n_{2n}n+11C2nn。共享栈：两个栈共
调用接口怎么记录到日志里面?项目中日志怎么做的? 北执南念工作中总结加强学习 java
调用接口怎么记录到日志里面?项目中日志怎么做的?文章目录调用接口怎么记录到日志里面?项目中日志怎么做的?1.日志记录的重要性1.1调试与排查1.2性能监控1.3审计与合规2.日志记录的实现2.1日志框架选择2.2日志记录策略2.3日志记录的最佳实践3.实现接口调用日志记录的3.1在SpringBoot项目中3.2使用AOP（面向切面编程）4.日志收集与分析4.1集中化日志管理4.2日志分析5.项目
【Unix/Linux】$bash-3.2是什么程序员赵大宝 Linux linux unix
bash-3.2指的是BourneAgainShell（Bash）的3.2版本。Bash是一个广泛使用的Unixshell和命令语言，是GNU项目的一部分，也是许多Linux发行版和Unix系统的默认shell。以下是一些关于Bash3.2的要点：1.兼容性：Bash3.2是Bash的一个较旧版本，但它仍然提供了与早期Unixshell（如BourneShell）的兼容性。2.特性：尽管Bash3
【蓝桥杯】大纲是Winky啊 #蓝桥杯蓝桥杯职场和发展
1.算法类1.1.枚举算法[1-3]就是把所有可能的情况都一一列举出来，然后从中找到符合要求的答案。比如从1到100找能被5整除的数，就一个一个试，这就是枚举。1.2.排序算法冒泡排序[2]像气泡往上冒一样，每次比较相邻的两个数，如果顺序不对就交换，一趟一趟地把最大（或最小）的数“浮”到最后。选择排序[3]每次从剩下的数中选一个最小（或最大）的，放到已经排好序的序列后面。插入排序[3]就像抓扑克牌
计算机视觉：COCO数据集 00&00 计算机视觉深度学习人工智能计算机视觉人工智能
COCO（CommonObjectsinContext）是一个广泛使用的计算机视觉数据集，主要用于图像识别、物体检测、分割和关键点检测等任务。以下是对COCO数据集的详细介绍，包括其特点、组成部分以及在计算机视觉中的应用。一、COCO数据集的特点1.规模庞大COCO数据集包含超过30万张图像，其中超过20万张图像有注释。这些图像来自不同的场景和对象，使得数据集具有广泛的代表性。2.丰富的标注信息物
农业机器人综述：技术现状、应用场景及未来展望橙蜂智能机器人
农业机器人综述：技术现状、应用场景及未来展望引言一、农业机器人的技术现状1.感知模块2.导航与定位模块3.控制与执行模块4.通信与数据传输模块5.决策与人工智能模块6.电源管理与能源模块二、农业机器人的应用场景1.播种与施肥2.植保与除草3.采摘与收获4.土壤和作物监测5.温室管理与环境控制6.多机器人协作三、农业机器人面临的挑战1.成本较高2.环境适应性差3.技术成熟度有待提高4.数据安全和隐私
利用Python pandas 数据清洗详细教程小白教程 python 运维数据库 python pandas 开发语言
文章目录前言一、环境搭建1.下载Python2.安装Python3使用pip安装Pandas二、使用步骤1.读取数据2.处理缺失值3.处理重复值4.处理异常值5.数据类型转换6.处理不一致的数据前言pandas是Python数据处理与分析的得力工具，功能强大，是数据从业者进行数据清洗的首选。本教程将系统介绍用pandas进行数据清洗，涵盖数据读取、缺失值与重复值处理、异常值修正、数据类型转换等要点
[失业前端恶补算法]JavaScript leetcode刷题top100（六）：字母异位词分组、最长连续序列、找到字符串中所有字母异位词、最大子数组和、除自身以外数组的乘积摸鱼老萌新失业前端恶补算法前端 javascript 动态规划算法哈希
专栏声明：只求用最简单的，容易理解的方法通过，不求优化，不喜勿喷49.字母异位词分组题面给你一个字符串数组，请你将字母异位词组合在一起。可以按任意顺序返回结果列表。字母异位词是由重新排列源单词的所有字母得到的一个新单词。知识点：哈希表、排序思路这里用了js语言的一个小技巧，我们可以使用split这个api将字符串变成字符的数组，之后我们对得到的数组进行排序，这样字母异位词得到了结果字符串的一致的，
预测股票走势的ai模型 roxxo AI模型人工智能深度学习金融
AI股票走势预测模型用深度学习+时间序列分析来构建一个股票预测AI，基于历史数据预测未来走势。1.关键功能✅AI选股（基于财务数据+技术指标）✅股票走势预测（LSTM/Transformer）✅智能筛选高增长潜力股✅可视化分析2.关键技术数据来源：YahooFinance/AlphaVantage财务分析：PE、EPS、ROE、PB、成交量机器学习选股：随机森林/XGBoost深度学习预测：LST
记事本制作弹窗病毒校园-小小白帽子小程序其他小程序
记事本制作弹窗"病毒"大家好，我叫xiaoxin，第一次写文章，有点小紧张，今天下午有空，我就随手写了个关于VisualBasic制作的小程序，本程序没有任何破坏性，纯属娱乐。0x00准备1.需要准备一台电脑2.有虚拟机的话建议用虚拟机运行0x01我们就开始制作1）.制作一个弹窗，最后另存为1.bat代码作用介绍第一行代码：“@echooff”用于隐藏代码。第二行代码：设置弹窗的标题和内容，标题为
LeetCode热题100刷题1：1.两数之和、49. 字母异位词分组、128. 最长连续序列每天努力进步！力扣hot100 leetcode 算法 c++哈希表
1.两数之和借助哈希表classSolution{public:vectortwoSum(vector&nums,inttarget){unordered_mapumap;for(inti=0;i>umap；定义这个结构十分巧妙，第一个元素表示对字符串排序后的单词（每个单词进行排序，若为异位词排序后必相同）第二个元素字符串数组存这同一类的字符串【auto自动数据类型无需指定类型】classSolu
Go算法之奇偶排序思远久安 Go数据结构与算法小白入门算法 golang 数据结构后端排序算法
一、什么是奇偶排序（以下排序步骤来自文心一言加上本人的一些理解，我觉得ai讲的比较透彻）奇偶排序步骤：初始化：给定一个待排序的数组。奇数轮次遍历：从索引1（即第二个元素，因为索引从0开始）开始，以步长为2（i+2）遍历数组。比较当前元素与其后一个元素（即索引为i和i+2的元素）。如果当前元素大于后一个元素，则交换它们的位置。偶数轮次遍历：从索引0开始，同样以步长为2遍历数组。执行与奇数轮次相同的比
麒麟SoC的详细架构组成介绍小蘑菇二号麒麟
目录麒麟SoC的主要组成部分1.应用处理器（ApplicationProcessor,AP）2.图形处理单元（GPU）3.神经网络处理单元（NPU）4.图像信号处理器（ISP）5.调制解调器（Modem,基带芯片）6.多媒体编解码器7.安全模块8.连接模块9.存储控制器10.电源管理单元（PMIC）典型麒麟SoC示例Kirin9000总结麒麟（Kirin）是华为自主研发的一系列高性能系统级芯片（S
jmeter--参数化球球别卷辣 jmeter
2.准备参数化数据文件创建一个CSV文件（例如login_data.csv），用来存储不同的用户名和密码组合，内容示例如下：plaintextusername,passworduser1,pass1user2,pass2user3,pass3这里第一行是表头，后续每行是一组用户名和密码数据。3.创建JMeter测试计划步骤1：新建测试计划打开JMeter，默认会有一个测试计划，你也可以点击菜单栏“
Notepad++ 中删除所有以 “pdf“ 结尾的行秃小弟 notepad++
Notepad++中删除所有以“pdf”结尾的行操作步骤1.打开文件：在Notepad++中打开你需要处理的文本文件。2.打开查找和替换对话框：按快捷键Ctrl+F，打开“查找和替换”对话框。3.启用正则表达式模式：在对话框的底部，找到“搜索模式”部分，勾选“正则表达式”（Regularexpression）。4.输入正则表达式：在“查找内容”框中，输入以下正则表达式以匹配以“pdf”结尾的行：.
Java 程序GC机制及性能稳定性调优分析 shines_m 性能测试 java jvm 开发语言压力测试
一、JVM资源监控工具1.jvisualVM工具VisualVM提供了一个可视界面，能够监控线程，内存情况，查看方法的CPU时间和内存中的对象，已被GC的对象；在JDK_HOME/bin目录下，双击jvisualvm.exe文件即可打开运行。打开后默认会监控本地运行的java程序，运行的界面如下：2.连接远程服务器，需要在被监控JVM服务器上启动jstatd服务JVMjstatDaemon：守护进
网游服务端分层架构酒与花生米架构
在网络游戏服务端的分层架构中，每一层都负责不同的任务和功能。下面是每一层及其常见模块的详细说明，1.客户端层（ClientLayer）模块：玩家界面：显示游戏界面、信息。输入处理：玩家的输入（如控制角色、点击按钮）处理。数据展示：展示从服务器获取的数据，如游戏状态、人物信息。与其他层的交互：向网络层发送请求，获取游戏数据。接收服务器返回的游戏状态，并在客户端进行展示。2.网络层（NetworkLa
css总结 threesevens 前端 css 前端
一、CSS引入二、CSS基本选择器1.通配选择器为所有元素设置样式*{padding:0;margin:0;}2.元素选择器为某种元素统一设置样式p{color:red;}3.类选择器为某个类名统一设置样式.className{color:red;}4.ID选择器为某个ID设置样式#idName{color:red;}三、复合选择器1.交集选择器选中同时符合多个条件的元素/*选中同时包含pid="
Java学习笔记范梦迪 java 笔记
第一章Java基础1.HelloWorld程序publicclassHelloWorld{publicstaticvoidmain(String[]args){System.out.println("Hello,World!");}}2.数据类型Java提供了多种数据类型，包括基本数据类型和引用数据类型。基本数据类型用于存储简单的数据值，而引用数据类型用于存储对象的引用。2.1基本数据类型Java
计数排序c++详解（看这一篇就够了） Lucas55555555 c++算法数据结构
计数排序（CountingSort）是一种非比较型的整数排序算法，适用于整数范围不大的数据排序。其基本思想是统计待排序数组中每个元素出现的次数，然后通过累加计数信息，将元素放回排序数组中。由于它是基于元素的出现频率来排序的，因此时间复杂度通常可以达到O(n)，但它对元素的范围（即最大值）有要求。定义：计数排序通过统计每个元素出现的次数来实现排序，然后根据这些统计结果重建排序后的数组。它是一种稳定的
分享100个最新免费的高匿HTTP代理IP mcj8089 代理IP 代理服务器匿名代理免费代理IP 最新代理IP
推荐两个代理IP网站： 1. 全网代理IP：http://proxy.goubanjia.com/ 2. 敲代码免费IP：http://ip.qiaodm.com/ 120.198.243.130:80,中国/广东省 58.251.78.71:8088,中国/广东省 183.207.228.22:83,中国/
mysql高级特性之数据分区 annan211 java 数据结构 mongodb 分区 mysql
mysql高级特性 1 以存储引擎的角度分析，分区表和物理表没有区别。是按照一定的规则将数据分别存储的逻辑设计。器底层是由多个物理字表组成。 2 分区的原理分区表由多个相关的底层表实现，这些底层表也是由句柄对象表示，所以我们可以直接访问各个分区。存储引擎管理分区的各个底层表和管理普通表一样(所有底层表都必须使用相同的存储引擎)，分区表的索引只是
JS采用正则表达式简单获取URL地址栏参数 chiangfai js 地址栏参数获取
GetUrlParam:function GetUrlParam(param){ var reg = new RegExp("(^|&)"+ param +"=([^&]*)(&|$)"); var r = window.location.search.substr(1).match(reg); if(r!=null
怎样将数据表拷贝到powerdesigner (本地数据库表) Array_06 powerDesigner
================================================== 1、打开PowerDesigner12，在菜单中按照如下方式进行操作 file->Reverse Engineer->DataBase 点击后，弹出 New Physical Data Model 的对话框 2、在General选项卡中 Model name:模板名字，自
logbackのhelloworld 飞翔的马甲日志 logback
一、概述 1.日志是啥？当我是个逗比的时候我是这么理解的：log.debug()代替了system.out.print(); 当我项目工作时，以为是一堆得.log文件。这两天项目发布新版本，比较轻松，决定好好地研究下日志以及logback。传送门1：日志的作用与方法： http://www.infoq.com/cn/articles/why-and-how-log 上面的作
新浪微博爬虫模拟登陆随意而生新浪微博
转载自：http://hi.baidu.com/erliang20088/item/251db4b040b8ce58ba0e1235 近来由于毕设需要，重新修改了新浪微博爬虫废了不少劲，希望下边的总结能够帮助后来的同学们。现行版的模拟登陆与以前相比，最大的改动在于cookie获取时候的模拟url的请求
synchronized 香水浓 java thread
Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍然
maven 简单实用教程 AdyZhang maven
1. Maven介绍 1.1. 简介 java编写的用于构建系统的自动化工具。目前版本是2.0.9，注意maven2和maven1有很大区别，阅读第三方文档时需要区分版本。 1.2. Maven资源见官方网站；The 5 minute test，官方简易入门文档；Getting Started Tutorial，官方入门文档；Build Coo
Android 通过 intent传值获得null aijuans android
我在通过intent 获得传递兑现过的时候报错，空指针,我是getMap方法进行传值，代码如下 1 2 3 4 5 6 7 8 9 public void getMap(View view){ Intent i =
apache 做代理报如下错误：The proxy server received an invalid response from an upstream baalwolf response
网站配置是apache＋tomcat,tomcat没有报错，apache报错是： The proxy server received an invalid response from an upstream server. The proxy server could not handle the request GET /. Reason: Error reading fr
Tomcat6 内存和线程配置 BigBird2012 tomcat6
1、修改启动时内存参数、并指定JVM时区（在windows server 2008 下时间少了8个小时）在Tomcat上运行j2ee项目代码时，经常会出现内存溢出的情况，解决办法是在系统参数中增加系统参数： window下，在catalina.bat最前面 set JAVA_OPTS=-XX:PermSize=64M -XX:MaxPermSize=128m -Xms5
Karam与TDD bijian1013 Karam TDD
一.TDD 测试驱动开发（Test-Driven Development,TDD）是一种敏捷（AGILE）开发方法论，它把开发流程倒转了过来，在进行代码实现之前，首先保证编写测试用例，从而用测试来驱动开发（而不是把测试作为一项验证工具来使用）。 TDD的原则很简单： a.只有当某个
[Zookeeper学习笔记之七]Zookeeper源代码分析之Zookeeper.States bit1129 zookeeper
public enum States { CONNECTING, //Zookeeper服务器不可用，客户端处于尝试链接状态 ASSOCIATING, //？？？ CONNECTED, //链接建立，可以与Zookeeper服务器正常通信 CONNECTEDREADONLY, //处于只读状态的链接状态，只读模式可以在
【Scala十四】Scala核心八：闭包 bit1129 scala
Free variable A free variable of an expression is a variable that’s used inside the expression but not defined inside the expression. For instance, in the function literal expression (x: Int) => (x
android发送json并解析返回json ronin47 android
package com.http.test; import org.apache.http.HttpResponse; import org.apache.http.HttpStatus; import org.apache.http.client.HttpClient; import org.apache.http.client.methods.HttpGet; import
一份IT实习生的总结 brotherlamp PHP php资料 php教程 php培训 php视频
今天突然发现在不知不觉中自己已经实习了 3 个月了，现在可能不算是真正意义上的实习吧，因为现在自己才大三，在这边撸代码的同时还要考虑到学校的功课跟期末考试。让我震惊的是，我完全想不到在这 3 个月里我到底学到了什么，这是一件多么悲催的事情啊。同时我对我应该 get 到什么新技能也很迷茫。所以今晚还是总结下把，让自己在接下来的实习生活有更加明确的方向。最后感谢工作室给我们几个人这个机会让我们提前出来
据说是2012年10月人人网校招的一道笔试题-给出一个重物重量为X,另外提供的小砝码重量分别为1，3，9。。。3^N。将重物放到天平左侧，问在两边如何添加砝码 bylijinnan java
public class ScalesBalance { /** * 题目： * 给出一个重物重量为X,另外提供的小砝码重量分别为1，3，9。。。3^N。（假设N无限大，但一种重量的砝码只有一个） * 将重物放到天平左侧，问在两边如何添加砝码使两边平衡 * * 分析： * 三进制 * 我们约定括号表示里面的数是三进制，例如 47=(1202
dom4j最常用最简单的方法 chiangfai dom4j
要使用dom4j读写XML文档,需要先下载dom4j包,dom4j官方网站在 http://www.dom4j.org/目前最新dom4j包下载地址:http://nchc.dl.sourceforge.net/sourceforge/dom4j/dom4j-1.6.1.zip 解开后有两个包,仅操作XML文档的话把dom4j-1.6.1.jar加入工程就可以了,如果需要使用XPath的话还需要
简单HBase笔记 chenchao051 hbase
一、Client-side write buffer 客户端缓存请求描述：可以缓存客户端的请求，以此来减少RPC的次数，但是缓存只是被存在一个ArrayList中，所以多线程访问时不安全的。可以使用getWriteBuffer()方法来取得客户端缓存中的数据。默认关闭。二、Scan的Caching 描述： next( )方法请求一行就要使用一次RPC,即使
mysqldump导出时出现when doing LOCK TABLES daizj mysql mysqdump 导数据
　　执行　mysqldump -uxxx -pxxx -hxxx -Pxxxx database tablename > tablename.sql　导出表时，会报 mysqldump: Got error: 1044: Access denied for user 'xxx'@'xxx' to database 'xxx' when doing LOCK TABLES 解决
CSS渲染原理 dcj3sjt126com Web
从事Web前端开发的人都与CSS打交道很多，有的人也许不知道css是怎么去工作的，写出来的css浏览器是怎么样去解析的呢？当这个成为我们提高css水平的一个瓶颈时，是否应该多了解一下呢？一、浏览器的发展与CSS
《阿甘正传》台词 dcj3sjt126com
Part Ⅰ: 《阿甘正传》Forrest Gump经典中英文对白 Forrest: Hello! My names Forrest. Forrest Gump. You wanna Chocolate? I could eat about a million and a half othese. My momma always said life was like a box ochocol
Java处理JSON dyy_gusi json
Json在数据传输中很好用，原因是JSON 比 XML 更小、更快，更易解析。在Java程序中，如何使用处理JSON，现在有很多工具可以处理，比较流行常用的是google的gson和alibaba的fastjson，具体使用如下： 1、读取json然后处理 class ReadJSON { public static void main(String[] args)
win7下nginx和php的配置 geeksun nginx
1. 安装包准备 nginx : 从nginx.org下载nginx-1.8.0.zip php：从php.net下载php-5.6.10-Win32-VC11-x64.zip， php是免安装文件。 RunHiddenConsole: 用于隐藏命令行窗口 2. 配置 # java用8080端口做应用服务器，nginx反向代理到这个端口即可 p
基于2.8版本redis配置文件中文解释 hongtoushizi redis
转载自： http://wangwei007.blog.51cto.com/68019/1548167 在Redis中直接启动redis-server服务时, 采用的是默认的配置文件。采用redis-server xxx.conf 这样的方式可以按照指定的配置文件来运行Redis服务。下面是Redis2.8.9的配置文
第五章常用Lua开发库3-模板渲染 jinnianshilongnian nginx lua
动态web网页开发是Web开发中一个常见的场景，比如像京东商品详情页，其页面逻辑是非常复杂的，需要使用模板技术来实现。而Lua中也有许多模板引擎，如目前我在使用的lua-resty-template，可以渲染很复杂的页面，借助LuaJIT其性能也是可以接受的。如果学习过JavaEE中的servlet和JSP的话，应该知道JSP模板最终会被翻译成Servlet来执行；而lua-r
JZSearch大数据搜索引擎颠覆者 JavaScript
系统简介：大数据的特点有四个层面：第一，数据体量巨大。从TB级别，跃升到PB级别；第二，数据类型繁多。网络日志、视频、图片、地理位置信息等等。第三，价值密度低。以视频为例，连续不间断监控过程中，可能有用的数据仅仅有一两秒。第四，处理速度快。最后这一点也是和传统的数据挖掘技术有着本质的不同。业界将其归纳为4个“V”——Volume，Variety，Value，Velocity。大数据搜索引
10招让你成为杰出的Java程序员 pda158 java 编程框架
如果你是一个热衷于技术的 Java 程序员，那么下面的 10 个要点可以让你在众多 Java 开发人员中脱颖而出。　　 1. 拥有扎实的基础和深刻理解 OO 原则　　对于 Java 程序员，深刻理解 Object Oriented Programming（面向对象编程）这一概念是必须的。没有 OOPS 的坚实基础，就领会不了像 Java 这些面向对象编程语言
tomcat之oracle连接池配置小网客 oracle
tomcat版本7.0 配置oracle连接池方式：修改tomcat的server.xml配置文件： <GlobalNamingResources> <Resource name="utermdatasource" auth="Container" type="javax.sql.DataSou
Oracle 分页算法汇总 vipbooks oracle sql 算法 .net
这是我找到的一些关于Oracle分页的算法，大家那里还有没有其他好的算法没？我们大家一起分享一下！ -- Oracle 分页算法一 select * from ( select page.*,rownum rn from (select * from help) page -- 20 = (currentPag

按字母分类： A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 其他