头歌作业之排序1、2、3、4

news2024/9/21 20:51:59

（PS：直接拿的友友zy的）

一个不知名大学生，江湖人称菜狗
original author: jacky Li
Email : 3435673055@qq.com

Time of completion：2023.1.1
Last edited: 2023.1.1

目录

（PS：直接拿的友友的）

排序1

第1关：简单选择排序算法

任务描述

相关知识

编程要求

测试说明

参考代码

 第2关：直接插入排序实现

任务描述

相关知识

编程要求

测试说明

参考代码

 第3关：折半插入排序实现

任务描述

相关知识

编程要求

测试说明

参考代码

排序2

第1关：希尔排序实现

任务描述

编程要求

测试说明

参考代码

 第2关：冒泡排序算法实现

任务描述

编程要求

测试说明

参考代码

排序3

第1关：快速排序算法实现

任务描述

编程要求

测试说明

参考代码

第2关：选择排序算法实现

任务描述

编程要求

测试说明

参考代码

排序4

第1关：堆排序算法实现

任务描述

编程要求

测试说明

参考代码

第2关：二路归并算法实现

任务描述

编程要求

测试说明

参考代码

作者有言

排序1

第1关：简单选择排序算法

任务描述

本关任务：试以单链表为存储结构，实现简单选择排序算法。

相关知识

为了完成本关任务，你需要掌握：链表的相关操作和掌握选择排序算法。

编程要求

根据提示，在右侧编辑器补充代码。

测试说明

平台会对你编写的代码进行测试：

参考代码

#include <iostream>
using namespace std;
#define OK 1;

typedef struct Node
{
	int data;
	struct Node *next;
}Node,*LinkedList;


int LinkCreate(LinkedList &head)
{
   int i=0,n;
   LinkedList p,rear;
   head = new Node;
   head->next = NULL;
   rear=head;
   cin>>n;
   while(i<n)
   {
   	    i++;
   	    p=new Node;
   	    cin>>p->data;
   	    p->next=NULL;
   	    rear->next=p;   //将新结点链入到尾部
		rear=p;       //新结点变成新的尾部 	    
    }
	return OK;	
}

void LinkedListSelectSort(LinkedList head)
//本算法一趟找出一个关键字最小的结点，其数据和当前结点进行交换;若要交换指针，则须记下
//当前结点和最小结点的前驱指针
{
	//###### Begin ###### 
LinkedList p, q, min;
	p = head;
	while(p->next) {
		q = p->next;
		min = q;
		while(q) {
			if(q->data < min->data) {
				min = q; //min指向数据元素最小的结点 
			}
			q = q->next;		
		}
		for(q = p; q->next != min; q = q->next); //q指针指向min指针的前一个 
		q->next = min->next; 
		min->next = p->next; //min指向的结点插入到p指针后面
		p->next = min;	
		p = p->next; //p指针后移一位 
	}

    // ###### End ######
}
void LinkOut(LinkedList head)  //对链表的输出 
{
	LinkedList p;
	p=head->next;
	while(p!=NULL)
	{
		cout<<p->data<<" ";
		p=p->next;		
	}
	cout<<endl;
}

int main()
{
	LinkedList head;
	if(LinkCreate(head))
		cout<<"创建成功"<<endl;
	LinkedListSelectSort(head);
	LinkOut(head);	
}

 第2关：直接插入排序实现

任务描述

本关任务：编写函数实现直接插入排序算法

相关知识

为了完成本关任务，你需要掌握：直接插入排序的算法思想。

编程要求

根据提示，在右侧编辑器补充代码

测试说明

平台会对你编写的代码进行测试：

参考代码

#include <iostream>
using namespace std;
# define MAXSIZE 20      //设记录不超过20个
# define OK 1; 

typedef  struct {                       //定义顺序表的结构
  int  r[MAXSIZE+1];   //存储顺序表的向量  r[0]一般作哨兵或缓冲区
  int length ;       //顺序表的长度
}SqList;
int ListCreate(SqList &L)
{
	int i=1,n;
	cin>>n;
	while(i<=n)
	{
		cin>>L.r[i];
		i++;
	}
	L.length=n;
	return OK;
}

void InsertSort(SqList &L)
{
	//###### Begin ###### 
	for(int i=1;i<=L.length;i++)
	{
		for(int j=i+1;j<=L.length;j++)
		{
			if(L.r[i]>=L.r[j])
			{
				swap(L.r[i],L.r[j] );
			}
		}
	}
    
    
    // ###### End ######
}
void ListOut(SqList L)
{
	int i;
	for(i=1;i<=L.length;i++)
	    cout<<L.r[i]<<" ";
	cout<<endl;
}
int main()
{
	SqList L;
	if(ListCreate(L))
	    cout<<"创建成功\n";
	InsertSort(L);
	ListOut(L);	
}

 第3关：折半插入排序实现

任务描述

本关任务：编写函数实现折半插入排序算法。

相关知识

为了完成本关任务，你需要掌握：折半插入排序算法。

编程要求

根据提示，在右侧编辑器补充代码

测试说明

平台会对你编写的代码进行测试：

测试输入：

5 （数字个数）

3 9 5 8 7 （数字序列）

预期输出：

创建成功

3 5 7 8 9

参考代码

#include <iostream>
using namespace std;
# define MAXSIZE 20      //设记录不超过20个
# define OK 1; 

typedef  struct {                       //定义顺序表的结构
  int  r[MAXSIZE+1];   //存储顺序表的向量  r[0]一般作哨兵或缓冲区
  int length ;       //顺序表的长度
}SqList;
int ListCreate(SqList &L)
{
	int i=1,n;
	cin>>n;
	while(i<=n)
	{
		cin>>L.r[i];
		i++;
	}
	L.length=n;
	return OK;
}

void  BInsertSort( SqList &L )
{
	//###### Begin ###### 
    int i,j;
    for(i = 2;i<=L.length;i++)
        {//如果遍历到的确实比前半部分最后一个大，插到尾部即可
            if(L.r[i]<L.r[i-1])
            {
                L.r[0] = L.r[i];//把r[0]作为哨兵，记录要执行此次插入的数据
                L.r[i] = L.r[i-1];//把i位置的数据换成i-1的数据，即已经使得前部分的数量+1
                //i-1位置的数据现在被记录到了第i个位置，本身存在无意义，可以理解为空出一个位置，看这个位置能不能插
                for(j=i-2;L.r[0]<L.r[j];--j)
                {   //这个循环是为了把要插入的空位置找到合适的地方
                    //j+1=i-1
                    L.r[j+1]=L.r[j];
                }
                //这个循环结束后肯定能找到合适的位置
                L.r[j+1]=L.r[0];
            }
        }

    
    // ###### End ######
}  // BInsertSort
void ListOut(SqList L)
{
	int i;
	for(i=1;i<=L.length;i++)
	    cout<<L.r[i]<<" ";
	cout<<endl;
}
int main()
{
	SqList L;
	if(ListCreate(L))
	    cout<<"创建成功\n";
	BInsertSort( L );
	ListOut(L);	
}

排序2

第1关：希尔排序实现

任务描述

本关任务：编写一个能实现希尔排序算法的函数。

编程要求

根据提示，在右侧编辑器补充代码

测试说明

平台会对你编写的代码进行测试：

参考代码

 #include <iostream>
using namespace std;
# define MAXSIZE 20      //设记录不超过20个
# define OK 1; 

typedef  struct {                       //定义顺序表的结构
  int  r[MAXSIZE+1];   //存储顺序表的向量  r[0]一般作哨兵或缓冲区
  int length ;       //顺序表的长度
}SqList;
int ListCreate(SqList &L)
{
	int i=1,n;
	cin>>n;
	while(i<=n)
	{
		cin>>L.r[i];
		i++;
	}
	L.length=n;
	return OK;
}
void ShellInsert(SqList &L,int dk) 
{
	//###### Begin ###### 
    int i,j;
	//从dk+1开始 
	for(i=dk+1 ; i<=L.length;i++)
	{
//从当前下标向前 与同一小组的数据进行比较，如果前面数据大，就把前面数据赋值给当前位置
		if( L.r[i] <L.r[i-dk] )//同一组元素中前一个相比较 
		{
			L.r[0]=L.r[i];//暂存哨兵
			for(j=i-dk; j>0 &&(L.r[0]<L.r[j]  ) ; j-=dk )
			{
				//后移
				L.r[j+dk]=L.r[j]; 
			} 
			//插入位置
			L.r[j+dk]=L.r[0]; 
		}
	}

      
    // ###### End ######
}
void ShellSort(SqList &L,int dlta[ ],int t) //按增量序列dlta[0…t-1]对顺序表L作Shell排序
{       
	for(int k=0;k<t;++k)
		ShellInsert(L,dlta[k]);//增量为dlta[k]的一趟插入排序
}  // ShellSort

void ListOut(SqList L)
{
	int i;
	for(i=1;i<=L.length;i++)
	    cout<<L.r[i]<<" ";
	cout<<endl;
}
int main()
{
	SqList L;
	int dlta[3]={5,3,1};
	if(ListCreate(L))
	    cout<<"创建成功\n";
	ShellSort( L,dlta,3 );
	ListOut(L);	
}

 第2关：冒泡排序算法实现

任务描述

本关任务：编写一个能实现希尔排序算法的函数。

编程要求

根据提示，在右侧编辑器补充代码

测试说明

平台会对你编写的代码进行测试：

参考代码

 #include <iostream>
using namespace std;
# define MAXSIZE 20      //设记录不超过20个
# define OK 1; 

typedef  struct {                       //定义顺序表的结构
  int  r[MAXSIZE+1];   //存储顺序表的向量  r[0]一般作哨兵或缓冲区
  int length ;       //顺序表的长度
}SqList;
int ListCreate(SqList &L)
{
	int i=1,n;
	cin>>n;
	while(i<=n)
	{
		cin>>L.r[i];
		i++;
	}
	L.length=n;
	return OK;
}
void ShellInsert(SqList &L,int dk) 
{
	//###### Begin ###### 
    int i,j;
	//从dk+1开始 
	for(i=dk+1 ; i<=L.length;i++)
	{
//从当前下标向前 与同一小组的数据进行比较，如果前面数据大，就把前面数据赋值给当前位置
		if( L.r[i] <L.r[i-dk] )//同一组元素中前一个相比较 
		{
			L.r[0]=L.r[i];//暂存哨兵
			for(j=i-dk; j>0 &&(L.r[0]<L.r[j]  ) ; j-=dk )
			{
				//后移
				L.r[j+dk]=L.r[j]; 
			} 
			//插入位置
			L.r[j+dk]=L.r[0]; 
		}
	}

      
    // ###### End ######
}
void ShellSort(SqList &L,int dlta[ ],int t) //按增量序列dlta[0…t-1]对顺序表L作Shell排序
{       
	for(int k=0;k<t;++k)
		ShellInsert(L,dlta[k]);//增量为dlta[k]的一趟插入排序
}  // ShellSort

void ListOut(SqList L)
{
	int i;
	for(i=1;i<=L.length;i++)
	    cout<<L.r[i]<<" ";
	cout<<endl;
}
int main()
{
	SqList L;
	int dlta[3]={5,3,1};
	if(ListCreate(L))
	    cout<<"创建成功\n";
	ShellSort( L,dlta,3 );
	ListOut(L);	
}

排序3

第1关：快速排序算法实现

任务描述

本关任务：编写一个能实现希尔排序算法的函数。

编程要求

根据提示，在右侧编辑器补充代码

测试说明

平台会对你编写的代码进行测试：

参考代码

#include <iostream>
using namespace std;
# define MAXSIZE 20      //设记录不超过20个
# define OK 1; 

typedef  struct {                       //定义顺序表的结构
  int  r[MAXSIZE+1];   //存储顺序表的向量  r[0]一般作哨兵或缓冲区
  int length ;       //顺序表的长度
}SqList;
int ListCreate(SqList &L)
{
	int i=1,n;
	cin>>n;
	while(i<=n)
	{
		cin>>L.r[i];
		i++;
	}
	L.length=n;
	return OK;
}

void QSort(SqList &L,int low, int high) 
{  
	//###### Begin ###### 
    if(low>=high) return ;
    
	int i=low-1 ,j =high+1 , mid = L.r[low + high >>1];
    while(i<j)
    {
    	do i++ ;while(L.r[i]<mid);
    	do j-- ; while(L.r[j]>mid);
    	if(i<j) 
    	swap(L.r[i],L.r[j]);
	}
    QSort(L,low, j);
    QSort(L,j+1,high);
    
    // ###### End ######
}


void ListOut(SqList L)
{
	int i;
	for(i=1;i<=L.length;i++)
	    cout<<L.r[i]<<" ";
	cout<<endl;
}
int main() 			 
{
	SqList L;
	if(ListCreate(L))
	    cout<<"创建成功\n";
	QSort(L,1,L.length);
	ListOut(L);
	return 0;	
}

第2关：选择排序算法实现

任务描述

本关任务：编写一个能实现希尔排序算法的函数。

编程要求

根据提示，在右侧编辑器补充代码

测试说明

平台会对你编写的代码进行测试：

参考代码

#include <iostream>
using namespace std;
# define MAXSIZE 20      //设记录不超过20个
# define OK 1; 

typedef  struct {                       //定义顺序表的结构
  int  r[MAXSIZE+1];   //存储顺序表的向量  r[0]一般作哨兵或缓冲区
  int length ;       //顺序表的长度
}SqList;
int ListCreate(SqList &L)
{
	int i=1,n;
	cin>>n;
	while(i<=n)
	{
		cin>>L.r[i];
		i++;
	}
	L.length=n;
	return OK;
}
void SelectSort(SqList &L)
{ 
	//###### Begin ###### 
	int i,j,min;//min存储L.r[i...n]中最小值的下标
	for(i=1;i<L.length;i++)
	{
		min=i;
		for(j=i+1;j<=L.length;j++)
		{
			if(L.r[j]<L.r[min])
				min=j;
			
		}
		if(min!=i)//如果min较比初值发生变化，则交换
		{
			L.r[0]=L.r[i]; 
			L.r[i]=L.r[min]; 
			L.r[min]=L.r[0];
		}
	}
 
    
    
    // ###### End ######
}
void ListOut(SqList L)
{
	int i;
	for(i=1;i<=L.length;i++)
	    cout<<L.r[i]<<" ";
	cout<<endl;
}
int main() 			 
{
	SqList L;
	if(ListCreate(L))
	    cout<<"创建成功\n";
	SelectSort(L);
	ListOut(L);
	return 0;	
}

排序4

第1关：堆排序算法实现

任务描述

本关任务：编写一个能实现希尔排序算法的函数。

编程要求

根据提示，在右侧编辑器补充代码

测试说明

平台会对你编写的代码进行测试：

参考代码

#include <iostream>
using namespace std;
# define MAXSIZE 20      //设记录不超过20个
# define OK 1; 

typedef  struct {                       //定义顺序表的结构
  int  r[MAXSIZE+1];   //存储顺序表的向量  r[0]一般作哨兵或缓冲区
  int length ;       //顺序表的长度
}SqList;
int ListCreate(SqList &L)
{
	int i=1,n;
	cin>>n;
	while(i<=n)
	{
		cin>>L.r[i];
		i++;
	}
	L.length=n;
	return OK;
}
void HeapAdjust(SqList &H,int s,int m)
{//从H中调整下标s的位置  一共M个元素 
	int j;
	int rc;
	rc=H.r[s];//将要移动的元素 暂存 
	//暂存堆顶r[s]到rc
	for(j=2*s ; j<=m; j*=2)//2*s是左孩子 
	{
		//如果左孩子<右孩子 
		if(j<m && H.r[j]<H.r[j+1] )//横比，j初值指向左孩子
		{
			++j;//就指向右孩子 
		}//如果右孩子大于左孩子，j指向右孩子，j指示关键字较大位置
		if(rc>=H.r[j])//如果基准值大于等于j的key 
			break;//纵比,如果…，定位成功
		H.r[s]=H.r[j];//指向当前结点的左孩子 
		s=j;//
		//否则,r[j]上移到s,s变为j, 然后j*=2,进入下一层
	}
	H.r[s]=rc;//插入 
	// 将调整前的堆顶记录rc到位置s中
}
 
void HeapSort(SqList &H)
{
	int i;
	int temp;
	for(i=H.length/2 ;i>0;--i)//建堆
	{
		HeapAdjust(H,i,H.length);
	}
	for(i=H.length ;i>1;--i)
	{
		//交换r[1]和r[i]
		temp=H.r[i];
		H.r[i]=H.r[1];
		H.r[1]=temp;
		HeapAdjust(H,1,i-1); //调整，使得1~i-1符合堆的定义
	}
 } 
void ListOut(SqList L)
{
	int i;
	for(i=1;i<=L.length;i++)
	    cout<<L.r[i]<<" ";
	cout<<endl;
}
int main() 			 
{
	SqList L;
	if(ListCreate(L))
	    cout<<"创建成功\n";
	HeapSort(L);
	ListOut(L);
	return 0;	
}

第2关：二路归并算法实现

任务描述

本关任务：编写一个能实现希尔排序算法的函数。

编程要求

根据提示，在右侧编辑器补充代码

测试说明

平台会对你编写的代码进行测试：

参考代码

#include <iostream>
using namespace std;
# define MAXSIZE 20      //设记录不超过20个
# define OK 1; 

typedef  struct {                       //定义顺序表的结构
  int  r[MAXSIZE+1];   //存储顺序表的向量  r[0]一般作哨兵或缓冲区
  int length ;       //顺序表的长度
}SqList;
int ListCreate(SqList &L)
{
	int i=1,n;
	cin>>n;
	while(i<=n)
	{
		cin>>L.r[i];
		i++;
	}
	L.length=n;
	return OK;
}

void RedCopy(int &r1,int r2)
{
    //复制元素r2到r1
    r1=r2;
}
void Merge(int R[],int T[],int low,int mid,int high)
{
	 //###### Begin ######
    //将相邻有序序列R[low..mid]和R[mid+1..high]归并为T[low..high]
    int i=low,j=mid+1,k=low; //ijk各遍历一序列
    while(i<=mid&&j<=high)
    {
        //选择两子序列中当前小的填入T[k]
        if(R[i]<=R[j])
	    RedCopy(T[k++],R[i++]);
	else
           RedCopy(T[k++],R[j++]);  
    }
    while(i<=mid) //剩余段复制到T
        RedCopy(T[k++],R[i++]);
    while(j<=high)
        RedCopy(T[k++],R[j++]);
    for(i=low;i<=high;i++) //将合并完的T复制到R 以便下次归并时用
        RedCopy(R[i],T[i]);

    
    
    // ###### End ######
}
void MSort(int R[],int T[],int low,int high)
{
	 //###### Begin ###### 
    /*归并排序
    若序列为1直接填入T即可，否则，将元序列一分为二，左右两侧子
    序列递归排序 最后调用归并函数进行归并 将R[low..high]归并排
    序到T[low..high] 下标不变*/
    int mid;
    if(low==high)
     RedCopy(T[low],R[low]);
    else
    {
        mid=(low+high)/2;
	MSort(R,T,low,mid); //递归排序到临时数组
        MSort(R,T,mid+1,high);
	Merge(R,T,low,mid,high); //归并到目标数组
    }
    
    
    // ###### End ######
}

void MergeSort(SqList &L)
{
	 //###### Begin ###### 
 
    //归并排序 递归实现
    int *T; //临时数组
    if(!(T=(int *)malloc((L.length+1)*sizeof(int ))))
        exit(0);
    MSort(L.r,T,1,L.length);
    free(T);
    T=NULL;
    
    
    // ###### End ######
}

void ListOut(SqList L)
{
	int i;
	for(i=1;i<=L.length;i++)
	    cout<<L.r[i]<<" ";
	cout<<endl;
}
int main() 			 
{
	SqList L;
	if(ListCreate(L))
	    cout<<"创建成功\n";
	MergeSort(L);
	ListOut(L);
	return 0;	
}

作者有言

如果感觉博主讲的对您有用，请点个关注支持一下吧，将会对此类问题持续更新……

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

SCI论文解读复现【NO.2】基于注意机制的YOLOv5改进算法在行星图像中的应用(代码已复现)

SCI论文解读复现【NO.2】基于注意机制的YOLOv5改进算法在行星图像中的应用(代码已复现)

此前出了目标检测算法改进专栏&#xff0c;但是对于应用于什么场景&#xff0c;需要什么改进方法对应与自己的应用场景有效果&#xff0c;并且多少改进点能发什么水平的文章&#xff0c;为解决大家的困惑&#xff0c;此系列文章旨在给大家解读发表高水平学术期刊中的SCI论文&am…
阅读更多...
EMNLP22提示模板生成：GPS: Genetic Prompt Search for Efficient Few-shot Learning

EMNLP22提示模板生成：GPS: Genetic Prompt Search for Efficient Few-shot Learning

GPS: Genetic Prompt Search for Efficient Few-shot Learning 1 简介 Genetic Prompt Search (GPS) 通过提示改进少样本学习&#xff0c;它利用遗传算法自动搜索高性能提示 遗传提示搜索 (GPS) 算法&#xff0c;该算法使用生成模型逐渐改变提示&#xff0c;并根据它们在小型…
阅读更多...
C语言网刷题记录

C语言网刷题记录

作者&#xff1a;会敲代码的Steve 座右铭&#xff1a;博学笃志&#xff0c;切问静思。 大家好久不见啊&#xff0c;一看时间我已经好久没发文章了&#xff0c;最近在刷OJ题和学习&#xff1b;就没那么多心思把时间花在写文章上了&#xff0c;我对此感到很抱歉&#xff0c;本文呢…
阅读更多...
int8，FLOPS，FLOPs，TOPS 等具体含义

int8，FLOPS，FLOPs，TOPS 等具体含义

1、定义 算力的计量单位FLOPS&#xff08;Floating-point operations per second&#xff09;&#xff0c;FLOPS表示每秒浮点的运算次数。具体使用时&#xff0c;FLOPS前面还会有一个字母常量&#xff0c;例如TFLOPS、PFLOPS。这个字母T、P代表次数&#xff0c;T代表每秒一万亿…
阅读更多...
Linux学习笔记——MySQL数据库管理系统安装部署

Linux学习笔记——MySQL数据库管理系统安装部署

5.1、MySQL数据库管理系统安装部署 5.1.1、简介 1、MySQL简介 MySQL数据库管理系统&#xff08;后续简称MySQL&#xff09;&#xff0c;是一款知名的数据库系统&#xff0c;其特点是&#xff1a;轻量、简单、功能丰富。 MySQL数据库可谓是软件行业的明星产品&#xff0c;无…
阅读更多...
xilinx ZYNQ 7000 AXI GPIO

xilinx ZYNQ 7000 AXI GPIO

.0AXI GPIO 第一部分 PS 和 PL之间的通讯有一个接口称为AXI。AXI总线具体的内容这边不去深究&#xff0c;可以理解为一种特殊协议的通讯方式。 AXI GPIO是什么意思&#xff1f; PL是FPGA它可以做成任何你想要的东西&#xff0c;做一个GPIO外设当然是可以的。 如上图所示&…
阅读更多...
DoIP协议从入门到精通——通信建立

DoIP协议从入门到精通——通信建立

在DoIP专栏中，关于DoIP文章，主要讲述从车辆物理连接、车辆声明、车辆通信激活（Routine Activation）和诊断通信几个步骤。 本文介绍了Tester与车辆获取物理连接、车辆声明自身信息后接下来需要操作的就是本文所要分享的内容：Tester与车辆控制器的通信建立。 一、通信模式…
阅读更多...
记一次堆外内存泄漏分析

记一次堆外内存泄漏分析

文章目录1. 背景2. JVM 内存分布与分析2.1 JVM 内存分布2.2 堆外内存泄漏分析思路2.3 服务器 JVM 参数配置及实际内存分布2.4 JVM native 内存查看2.5 手动触发 Full GC3. 问题排查经历3.1 定位内存泄漏的位置及初步猜想1&#xff09;定位 RES 区域存在内存泄漏2&#xff09;分…
阅读更多...
寒假每日一题W1D1——孤独的照片

寒假每日一题W1D1——孤独的照片

题目描述 Farmer John 最近购入了 N 头新的奶牛&#xff0c;每头奶牛的品种是更赛牛&#xff08;Guernsey&#xff09;或荷斯坦牛&#xff08;Holstein&#xff09;之一。 奶牛目前排成一排&#xff0c;Farmer John 想要为每个连续不少于三头奶牛的序列拍摄一张照片。 然而&…
阅读更多...
一本通 1267：【例9.11】01背包问题（详细代码）

一本通 1267：【例9.11】01背包问题（详细代码）

经典01背包问题 这里给你3种方法 目录 DFS 思路&#xff1a; 代码&#xff1a; DFS记忆化 思路&#xff1a; 代码&#xff1a; 动态规划 思路&#xff1a; 代码&#xff1a; DFS 时间复杂度 &#xff1a;O(2^n) 思路&#xff1a; DFS求出所有选法&#xff0c;再用…
阅读更多...
Maven 之 依赖管理

Maven 之 依赖管理

目录 1、依赖传递 小案例&#xff1a; 2、可选依赖 3、 排除依赖 4、可选依赖和排除依赖的区别 我们开发一个工程需要用到大量得jar包&#xff0c;而这些jar 包就是我们所说得依赖&#xff0c;一个项目可以配置多个依赖。 1、依赖传递 我们来看一下今天用来演示的工程。…
阅读更多...
Linux性能学习（1.4）：CPU_如何查看CPU上下文切换参数

Linux性能学习（1.4）：CPU_如何查看CPU上下文切换参数

文章目录1 系统总体上下文参数2 进程的上下文切换参数3 其它参考资料&#xff1a;vmstat&#xff1a;一个标准的报告虚拟内存统计工具 在前面大致了解了上下文切换的相关知识&#xff0c;那么如何在系统中查看上下文切换相关的参数&#xff1f; 1 系统总体上下文参数 使用vm…
阅读更多...
人工势场法路径规划算法（APF）

人工势场法路径规划算法（APF）

本文主要对人工势场法路径规划算法进行介绍&#xff0c;主要涉及人工势场法的简介、引力和斥力模型及其推导过程、人工势场法的缺陷及改进思路、人工势场法的Python与MATLAB开源源码等方面 一、人工势场法简介 人工势场法是由Khatib于1985年在论文《Real-Time Obstacle Avoidan…
阅读更多...
WPF使用触发器需要注意优先级问题

WPF使用触发器需要注意优先级问题

总目录 文章目录总目录前言一、问题开始二、问题说明三、问题订正总结前言 WPF使用触发器需要注意优先级问题 一、问题开始 现在有个需求&#xff1a; 初始状态&#xff08;未选中&#xff09;的时候&#xff0c;CheckBox的Content 为 “乒乓球”&#xff0c;然后选中之后&am…
阅读更多...
python机器学习《基于逻辑回归的预测分类》

python机器学习《基于逻辑回归的预测分类》

前言&#xff1a; 本文所有代码均在阿里天池实验室运行&#xff0c;本机的jupyter notebook也可运行。除此之外&#xff0c;还需要导入numpy,matplotlib,sklearn,seaborn包。每期文章前面都会有环境搭建说明。文中的讲解知识点均是按照从上往下讲解&#xff0c;将一些平常未接触…
阅读更多...
⼯⼚⽅法模式

⼯⼚⽅法模式

⼯⼚⽅法模式 ⼯⼚⽅法模式&#xff0c;属于创建者模式中的一种&#xff0c;这类模式提供创建对象的机制&#xff0c; 能够提升已有代码的灵活性和可复⽤性。 创建者模式包括&#xff1a;⼯⼚⽅法、抽象⼯⼚、⽣成器、原型、单例&#xff0c;这5类。 1.⼯⼚⽅法模式介绍 ⼯⼚…
阅读更多...
LaoCat带你认识容器与镜像（二【一章】）

LaoCat带你认识容器与镜像（二【一章】）

系列二章&#xff0c;祝大家新的一年事事顺心&#xff0c;想要的一定都实现。 本章内容 使用Docker镜像。 本文实操全部基于Ubuntu 20.04 一、使用Docker镜像 镜像&#xff08;image&#xff09;是Docker三大核心概念中最重要的&#xff0c;Docker运行容器前需要本地存在对应得…
阅读更多...
在wsl下开发T113的主线linux（5）-构建ubi文件系统

在wsl下开发T113的主线linux（5）-构建ubi文件系统

接下来是构建文件系统&#xff0c;这里使用最新的buildroothttps://buildroot.org/download.htmlhttps://buildroot.org/download.html tar xf buildroot-2022.11.tar.gz cd buildroot-2022.11 make menuconfig 配置目标指令集类型 配置外部自定义编译器 配置生成文件系统类型…
阅读更多...
数据结构和算法--算法与数据结构的概述、简单排序

数据结构和算法--算法与数据结构的概述、简单排序

目录 算法 算法概述 算法复杂度 数据结构 数据结构的概述 物理结构 逻辑结构 简单排序 1.选择排序 1.1算法描述 1.2算法实现 2冒泡排序 2.1算法描述 2.2算法实现 3插入排序 3.1算法描述 3.2算法实现 三种算法的比较 算法 算法概述 算法是一系列程序指令&am…
阅读更多...
回溯算法题型

回溯算法题型

目录 一组合总和 二组合总和 三子集 四全排列 五解数独 一组合总和 题目描述&#xff1a; 找出所有相加之和为 n 的 k 个数的组合&#xff0c;且满足下列条件&#xff1a; 只使用数字1到9每个数字 最多使用一次 返回 所有可能的有效组合的列表 。该列表不能包含相同的组…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023