两的算法

A. 至少两种算法

B. 如何比较两个算法的好坏，有什么指标

算法是一个良定义的计算过程，以一个或多个值输入，并以一个或多个值输出。
评价算法的好坏的因素：·算法是正确的；
·执行算法的时间；
·执行算法的存储空间（主要是辅助存储空间）；
·算法易于理解、编码、调试。
**************************************************************************************************************
时间复杂度：是某个算法的时间耗费，它是该算法所求解问题规模n的函数。
渐近时间复杂度：是指当问题规模趋向无穷大时，该算法时间复杂度的数量级。
评价一个算法的时间性能时，主要标准就是算法的渐近时间复杂度。
算法中语句的频度不仅与问题规模有关，还与输入实例中各元素的取值相关。
时间复杂度按数量级递增排列依次为：常数阶O(1)、对数阶O(log2n)、线性阶O(n)、线性对数阶O(nlog2n)、平方阶O(n^2)、立方阶O(n^3)、……k次方阶O(n^k)、指数阶O(2^n)。
空间复杂度：是某个算法的空间耗费，它是该算法所求解问题规模n的函数。
算法的时间复杂度和空间复杂度合称算法复杂度。

C. 两种算法

因为0-1背包是最优子结构问题，贪心法解决不了最优子结构问题。

D. 两种算法的区别

看到问题所在了，楼上两位都没讲到点子上

问题出在第二个算法的第一个if上

如果xx[i][j]是b的话，那么会进入第一个if，b会变成a
在第一个if后xx[i][j]变成了a，那么又会进入第二个if，a又会变成z
相对于xx[i][j]直接从b变成了z

之所以加了个else就没问题了是因为进了第一个if就不会再进第二个if！

E. 两数之和的算法

解：设一个数为x，则另一个数为（x-284）
x+（x-284）=954
2x-284=954
2x= 954+284
x=1238
x=619
619-284=535

答：两数分别为619和535.

F. 两种算法 那个是对的

你的精度有问题。
在计算过程中你使用的是小数（有理数）而不是带根号的无理数。
你的估算只用了3位小数。有问题也是很正常的。
建议在计算过程中均使用无理数。在最后的结果，如果需要转换为小数，在转换为小数。

G. 比较两个算法的不同

l=l+0/s的位置不一样，第公式是o和s的值发生了变化。第二个公式，os的值还没发生变化。

H. 用两种算法的算式

1: 3.6*4.8+3.6*2.4
2: 3.6*(4.8+2.4)

I. 这两个算法的具体区别是什么

楼主你好，我看了会觉得说不清楚，那就直接找了度娘。
度娘上一个人的问题是：

a=dv／dt这个公式如何理解，为什么不是Δv／Δt? 关于这个公式能不能给具体的一道题？以下是满意答案：按照严格的意义来说，加速度的定义应该是前者，也就是 a = dv/dt 。意思是加速度是速度的微分，也就是说加速度是速度表达式对时间的求导。而 △v/△t 只是一个差分比值，不是加速度的严格定义，这二者只在匀加速直线运动的情况下才相等。比方说，现在有一运动物体的速度规律是 V(t) = 5t^2那么根据加速度的微分定义 a（t） = dv（t）/dt = 10t ,也就是说这个物体的运动加速度是随之间改变的。然后再看差分式子 △V(t)/△t = [V(t + △t) - V(t)]/△t = [5(t + △t)^2 - 5t^2]/△t = (10t·△t + 5△t^2)/△t = 10t + 5△t即 △V(t)/△t = 10t + 5△t我们可以看到，这两个式子的差别就在于差分式子多了一个 5△t 。如果对△V(t)/△t取极限，也就是这个△t无限小的时候，5△t就是零了，剩下的就成了微分式子。 那么这就有了加速度微分定义是速度在某个时间点的速度变化率，而差分定义是速度在某个时间段的速度变化率。 当时间段无穷小时，时间段的起始点重合成一个点，那么差分定义就变成了微分定义。//如果满意，望采纳！~~

J. 求两个算法：C++版的

//1.循环链表
#include<iostream>
usingnamespacestd;

//每个类模板或函数模板对应一个template关键字
template<typenameT>
classNode{
	public:
		Tval;
		Node*next;
		Node(Tval){
			this->val=val;
			this->next=NULL;
		}
		Node(Tval,Node*next){
			this->val=val;
			this->next=next;			
		}
};

//循环链表
template<typenameT>
classCLinkedList{
	private:
		Node<T>*head;
		intlen;
	public:
		CLinkedList(){
			head=NULL;
			len=0;
		}
		~CLinkedList(){
			if(head!=NULL){
				Node<T>*p1=head->next;
				Node<T>*p2=NULL;//p2保存即将释放的p1指向的下一个节点
				head->next=NULL;//将循环链表由第0，第1个元素处断开
				for(;p1!=NULL;p1=p2){
					p2=p1->next;
					deletep1;
				}
			}
		}
		intlength(){
			returnthis->len;
		}
		//在循环链表的第pos个位置(pos从0开始)处插入节点
		boolinsert(Node<T>*p,intpos){
			if(pos<0||pos>len){
				returnfalse;
			}else{
				if(pos==0){
					if(len==0){
						p->next=p;//只有一个节点时,节点指向它自己
					}else{
						p->next=head;
					}
					head=p;
				}else{
					Node<T>*tmp=head;
					for(inti=1;i<pos;i++){
						tmp=tmp->next;
					}
					p->next=tmp->next;
					tmp->next=p;
				}
				len++;
				returntrue;
			}
		}
		//返回被删除的元素
		Node<T>*remove(intpos){
			if(pos<0||pos>=len){
				returnNULL;
			}else{
				Node<T>*p=NULL;
				if(pos==0){//考虑删除首元素的情况
					p=head;	
					head=head->next;
				}else{
					Node<T>*tmp=head;
					for(inti=1;i<pos;i++){
						tmp=tmp->next;
					}
					p=tmp->next;
					tmp->next=tmp->next->next;
				}
				len--;
				returnp;//返回被删除的元素
			}
		}
		//定位某个元素在循环链表中的首次出现的位置
		intgetPos(Node<T>*p){
			if(len<=0)
				return-1;
			else{
				Node<T>*pt=head;
				for(inti=0;i<len;i++){
					if(pt->val==p->val)
						returni;
					pt=pt->next;
				}
			}
			return-1;//未找到该元素
		}
		//打印输出整个链表中元素的值等操作
		voidprtMe(){
			Node<T>*p=head;
			cout<<"CList:";
			for(inti=0;i<len;i++){
				cout<<p->val;
				p=p->next;
				cout<<(i==len-1?"
":"");
			}
		}
};

intmain()
{	

	CLinkedList<int>CList;
	for(inti=0;i<10;i++){
		Node<int>*p=newNode<int>(i);//动态创建链表
		CList.insert(p,CList.length());
	}
	CList.prtMe();
	//插入元素
	CList.insert(newNode<int>(111),5);
	CList.prtMe();
	
	//删除元素
	CList.remove(0);
	CList.prtMe();

	//获取元素索引
	Node<int>n(6);//
	cout<<"len="<<CList.length()<<endl<<"getPos()="<<CList.getPos(&n)<<endl;//

return(0);
}

执行结果:

//2.双向链表
#include<iostream>
usingnamespacestd;

//每个类模板或函数模板对应一个template关键字
template<typenameT>
classNode{
public:
Tval;
Node*last;
Node*next;
Node(Tval){
this->val=val;
this->last=NULL;
this->next=NULL;
}
Node(Tval,Node*last,Node*next){
this->val=val;
this->last=last;
this->next=next;
}
};

//双向链表
template<typenameT>
classDLinkedList{
private:
Node<T>*head;
Node<T>*tail;
intlen;
public:
DLinkedList(){
this->head=NULL;
this->tail=NULL;
len=0;
}
~DLinkedList(){
Node<T>*p1=head;
Node<T>*p2=NULL;
for(;p1!=NULL;p1=p2){
p2=p1->next;
deletep1;
}
}
intlength(){
returnthis->len;
}
//在循环链表的第pos个位置(pos从0开始)处插入节点
boolinsert(Node<T>*p,intpos){
if(pos<0||pos>len){
returnfalse;
}else{
if(pos==0){//插入位置为0
if(len==0){
p->last=NULL;
p->next=NULL;
head=tail=p;
}else{
p->next=head;
head->last=p;
head=p;
p->last=NULL;
}
}elseif(pos==len){//插入位置为len处(最后一个元素后面)
p->last=tail;
p->next=NULL;
tail->next=p;
tail=p;
}else{//插入到其他位置
Node<T>*pt=head;
for(inti=1;i<pos;i++){
pt=pt->next;
}
p->last=pt;
p->next=pt->next;
pt->next->last=p;
pt->next=p;
}
len++;
returntrue;
}
}
//返回被删除的元素
Node<T>*remove(intpos){
if(pos<0||pos>=len){
returnNULL;
}else{
Node<T>*p=NULL;
if(len==1){//仅有一个元素
p=head;
tail=head=NULL;
returnp;
}

if(pos==0){//考虑删除首元素的情况
p=head;
head=head->next;
}elseif(pos==len-1){//考虑删除最后一个元素的情况
p=tail;
tail=p->last;
p->last->next=NULL;
p->last=NULL;
}else{
Node<T>*tmp=head;
for(inti=1;i<pos;i++){
tmp=tmp->next;
}
p=tmp->next;
tmp->next=p->next;
p->next->last=tmp;
p->next=p->last=NULL;
}
len--;
returnp;//返回被删除的元素
}
}
//定位某个元素在循环链表中的首次出现的位置
intgetPos(Node<T>*p){
if(len<=0)
return-1;
else{
Node<T>*pt=head;
for(inti=0;i<len;i++){
if(pt->val==p->val)
returni;
pt=pt->next;
}
}
return-1;//未找到该元素
}
//打印输出整个链表中元素的值等操作
voidprtMe(){
Node<T>*p=head;
cout<<"DList:";
for(inti=0;i<len;i++){
cout<<p->val;
p=p->next;
cout<<(i==len-1?" ":"");
}
}

};


intmain()
{

DLinkedList<int>DList;
for(inti=0;i<10;i++){
Node<int>*p=newNode<int>(i);//动态创建链表节点
DList.insert(p,DList.length());
}
DList.prtMe();
//插入元素
DList.insert(newNode<int>(111),5);
DList.insert(newNode<int>(1000),DList.length());
DList.prtMe();

//删除元素
DList.remove(0);
DList.remove(DList.length()-1);
DList.prtMe();

//获取元素索引
Node<int>n(6);//
cout<<"len="<<DList.length()<<endl<<"getPos()="<<DList.getPos(&n)<<endl;//

return(0);
}