兩的演算法

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);
}