两的算法
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);
}