雙轉演算法

㈠ 16進制轉2進制演算法內容是什麼

方法：先轉成十進制 然後轉換成其他進制；

一個二進制數，從最後一位開始算，依次列為第0、1、2...n位

如11010，從右開始數，分別為 01011

0 第0位；

1 第1位；

0 第2位；

1 第3位；

1 第4位；

二進制中的0不算，只看1出現在第幾位，算出2的 第n次方，然後將他們全都加起來

(1)雙轉演算法擴展閱讀：

對於任何一個數，我們可以用不同的進位制來表示。比如：十進數57(10)，可以用二進製表示為111001(2)，也可以用五進製表示為212（5)，也可以用八進製表示為71(8)、用十六進製表示為39(16)，它們所代表的數值都是一樣的。

由於人類解剖學的特點，雙手共有十根手指，故在人類自發採用的進位制中，十進制是使用最為普遍的一種。成語「屈指可數」某種意義上來說描述了一個簡單計數的場景，而原始人類在需要計數的時候，首先想到的就是利用天然的算籌——手指來進行計數。

㈡ 有一個序列4，10，6.當生成平衡二叉樹時插入值為6的節點時應該做什麼類型的

因為4 為根，10 為4 的右子樹，因此接著插入的6應當插入在10 的左子樹上，這樣就不平衡了，需要做先右後左的雙旋轉RL，最後6為根，4是左子樹，10 是右子樹。

1、可以使用標準的平衡二叉樹的演算法，從頭到尾一個一個插入，生成平衡二叉樹。

2、可以使用標準的平衡二叉樹的演算法，從尾到頭一個一個插入，生成平衡二叉樹。

2、可以對序列先排序，再生成平衡二叉樹，甚至生成完全二叉樹。

關鍵是否有約束條件，如果約束了必須從頭到尾，一個一個按照標准演算法插入，最終的樹是固定的。

(2)雙轉演算法擴展閱讀：

①結點：包含一個數據元素及若干指向子樹分支的信息。

②結點的度：一個結點擁有子樹的數目稱為結點的度。

③葉子結點：也稱為終端結點，沒有子樹的結點或者度為零的結點。

④分支結點：也稱為非終端結點，度不為零的結點稱為非終端結點。

⑤樹的度：樹中所有結點的度的最大值。

㈢ 期貨博弈大師怎麼看

是空換，空開，多換，多開，雙開，雙平，多平，空平吧，期貨交易的八種性質，舉個例子吧，這個很難說明白，畫圖的話比較好說。
多換：就是在多方市場上，好比你買入一手開倉，同時有人賣出一手平倉，你們
兩個成交的話，就叫多換，現手2，持倉+0
空換：在空方市場上你賣出一手開倉，同時有人買入一手平倉，你們成交的話就
叫空換，現手是2，持倉+0
多開:例有人買入兩手開倉，同時有人賣出一手平倉，還有人人賣出一手開倉，
這三人成交，就是多開，現手是4，持倉+2
空開：例有人賣出兩手開倉，同時有人買入一手平倉，還有人買入一手開倉，這
三人成交，即是空開，現手是4，持倉+2
多平：例有人賣出兩手平倉，同時有人買入一手開倉，還有人買入一手平倉，這
幾人成交，就叫多平，現手是4，持倉-2
空平：一樣例有人買入兩手平倉，同時有人賣出一手開倉，還有人賣出一手平
倉，三人成交就是空平，現手是4，持倉-2
雙開：就是雙方同時開倉，有人買入一手開倉，同時有人賣出一手開倉，成交就
是雙開，現手2，持倉+2
雙平：就是雙方同時平倉，例有人買入一手平倉，同時有人賣出一手平倉，雙方
成交，即是雙平。現手2，持倉-2
只是舉了一個簡單的例子，在期貨市場上，同一時間內有很多人交易的，也有很多手單子

㈣ 數據的演算法都有哪些……

A*搜尋演算法
俗稱A星演算法。這是一種在圖形平面上，有多個節點的路徑，求出最低通過成本的演算法。常用於游戲中的 NPC的移動計算，或線上游戲的 BOT的移動計算上。該演算法像 Dijkstra演算法一樣，可以找到一條最短路徑；也像BFS一樣，進行啟發式的搜索。

Beam Search
束搜索(beam search)方法是解決優化問題的一種啟發式方法，它是在分枝定界方法基礎上發展起來的，它使用啟發式方法估計k個最好的路徑，僅從這k個路徑出發向下搜索，即每一層只有滿意的結點會被保留，其它的結點則被永久拋棄，從而比分枝定界法能大大節省運行時間。束搜索於20 世紀70年代中期首先被應用於 人工智慧領域,1976 年Lowerre在其稱為 HARPY的語音識別系統中第一次使用了束搜索方法。他的目標是並行地搜索幾個潛在的最優決策路徑以減少回溯，並快速地獲得一個解。

二分取中查找演算法
一種在有序數組中查找某一特定元素的搜索演算法。搜素過程從數組的中間元素開始，如果中間元素正好是要查找的元素，則搜素過程結束；如果某一特定元素大於或者小於中間元素，則在數組大於或小於中間元素的那一半中查找，而且跟開始一樣從中間元素開始比較。這種搜索演算法每一次比較都使搜索范圍縮小一半。

Branch and bound
分支定界演算法是一種在問題的解空間樹上搜索問題的解的方法。但與回溯演算法不同，分支定界演算法採用廣度優先或最小耗費優先的方法搜索解空間樹，並且，在分支定界演算法中，每一個活結點只有一次機會成為擴展結點。

數據壓縮
數據壓縮是通過減少計算機中所存儲數據或者通信傳播中數據的冗餘度，達到增大數據密度，最終使數據的存儲空間減少的技術。數據壓縮在文件存儲和分布式系統領域有著十分廣泛的應用。數據壓縮也代表著尺寸媒介容量的增大和網路帶寬的擴展。

Diffie–Hellman密鑰協商
Diffie–Hellman key exchange，簡稱「D–H」，是一種安全協議。它可以讓雙方在完全沒有對方任何預先信息的條件下通過不安全信道建立起一個密鑰。這個密鑰可以在後續的通訊中作為對稱密鑰來加密通訊內容。

Dijkstra』s 演算法
迪科斯徹演算法（Dijkstra）是由荷蘭計算機科學家艾茲格·迪科斯徹發明的。演算法解決的是有向圖中單個源點到其他頂點的最短路徑問題。舉例來說，如果圖中的頂點表示城市，而邊上的權重表示著城市間開車行經的距離，迪科斯徹演算法可以用來找到兩個城市之間的最短路徑。

動態規劃
動態規劃是一種在 數學和計算機科學中使用的，用於求解包含重疊子問題的最優化問題的方法。其基本思想是，將原問題分解為相似的子問題，在求解的過程中通過子問題的解求出原問題的解。 動態規劃的思想是多種演算法的基礎，被廣泛應用於計算機科學和工程領域。比較著名的應用實例有：求解最短路徑問題，背包問題，項目管理，網路流優化等。這里也有一篇文章說得比較詳細。

歐幾里得演算法
在 數學中，輾轉相除法，又稱 歐幾里得演算法，是求 最大公約數的演算法。輾轉相除法首次出現於 歐幾里得的《幾何原本》（第VII卷，命題i和ii）中，而在中國則可以追溯至 東漢出現的《九章算術》。

快速傅里葉變換(FFT)
快速傅里葉變換（Fast Fourier Transform，FFT），是離散傅里葉變換的快速演算法，也可用於計算離散傅里葉變換的逆變換。快速傅里葉變換有廣泛的應用，如數字信號處理、計算大整數乘法、求解偏微分方程等等。

哈希函數
HashFunction是一種從任何一種數據中創建小的數字「指紋」的方法。該 函數將數據打亂混合，重新創建一個叫做散列值的指紋。散列值通常用來代表一個短的隨機字母和數字組成的字元串。好的散列 函數在輸入域中很少出現散列沖突。在散列表和數據處理中，不抑制沖突來區別數據，會使得資料庫記錄更難找到。

堆排序
Heapsort是指利用堆積樹（堆）這種 數據結構所設計的一種排序演算法。堆積樹是一個近似完全二叉樹的結構，並同時滿足堆積屬性：即子結點的鍵值或索引總是小於（或者大於）它的父結點。

歸並排序
Merge sort是建立在歸並操作上的一種有效的排序演算法。該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。

RANSAC 演算法
RANSAC 是」RANdom SAmpleConsensus」的縮寫。該演算法是用於從一組觀測數據中估計 數學模型參數的迭代方法，由Fischler and Bolles在1981提出，它是一種非確定性演算法，因為它只能以一定的概率得到合理的結果，隨著迭代次數的增加，這種概率是增加的。該演算法的基本假設是觀測數據集中存在」inliers」（那些對模型參數估計起到支持作用的點）和」outliers」（不符合模型的點），並且這組觀測數據受到雜訊影響。RANSAC 假設給定一組」inliers」數據就能夠得到最優的符合這組點的模型。

RSA加密演演算法
這是一個公鑰加密演算法，也是世界上第一個適合用來做簽名的演算法。今天的RSA已經 專利失效，其被廣泛地用於 電子商務加密，大家都相信，只要密鑰足夠長，這個演算法就會是安全的。

並查集Union-find
並查集是一種樹型的 數據結構，用於處理一些不相交集合（Disjoint Sets）的合並及查詢問題。常常在使用中以森林來表示。

Viterbi algorithm
尋找最可能的隱藏狀態序列
等等這些，演算法很多。

㈤ 清考要用，數據結構的，請高手回答。

16C 17C 18A 19A 20C 21B 22A 23B 24A 25C 26C 27B 28A 29A 30C 31C 32D

㈥ C++ 雙向循環鏈表 演算法設計

#ifndef LISTNODE_H
#define LISTNODE_H
template<class T>class LIST;
template<class T>
class LISTNODE
{
friend class LIST<T>;
public:
LISTNODE();
LISTNODE(const T &x);
T GetData()const {return data;}
private:
T data;
LISTNODE<T> *next;
};
template<class T>
LISTNODE<T>::LISTNODE():next(0){}
template<class T>
LISTNODE<T>::LISTNODE(const T&x):data(x),next(0){}
#endif

#ifndef LIST_H
#define LIST_H
#include <iostream.h>
#include "LISTNODE.H"

template<class T>
class LIST
{
public:
LIST();
LIST(const T&x);
~LIST();
bool Insert(const T &x,const int i);
bool Remove(const int i);
int Length()const;
bool IsEmpty()const {return first->next==0;}
void MakeEmpty();
T GetPrivor(const T&)const;
T GetNext(const T&)const;
void Print()const;
T GetData(const int i)const;
LISTNODE<T>*Find(const T&x);
void SetData(const T&x){first->data=x;}
// void CreateList();
private:
LISTNODE<T>*first,*last;

};
template<class T>
LIST<T>::LIST()
{
last=first=new LISTNODE<T>(0);
}
template<class T>
LIST<T>::LIST(const T&x)
{
last=first=new LISTNODE<T>(x);
}
template<class T>
LIST<T>::~LIST()
{
MakeEmpty();
delete first;
last=first=0;
}
template<class T>
void LIST<T>::MakeEmpty()
{
LISTNODE<T> *q;
while(first->next!=0)
{
q=first->next;
first->next=q->next;
delete q;
}
last=first;
}
template<class T>
bool LIST<T>::Insert(const T& x,const int i)
{
LISTNODE<T>*p=first;
int k=0;
while(p!=0&&k<i-1)
{
k++;
p=p->next;
}
if(p==0||i<0)
{
//cerr<<"no this position"<<endl;
return false;
}
else
{
LISTNODE<T>*newnode=new LISTNODE<T>(x);
newnode->next=p->next;
if(p->next==0)
last=newnode;
p->next=newnode;
}
return true;
}
template<class T>
int LIST<T>::Length()const
{
LISTNODE<T>*p=first->next;
int i=0;
while(p!=0)
{
p=p->next;
i++;
}
return i;
}
/*template<class T>
void LIST<T>::Print()const
{
LISTNODE<T> *p=first;
while(p!=0)
{
cout<<p->data<<" ";
p=p->next;
}
/cout<<endl;
}*/
template<class T>
bool LIST<T>::Remove(const int i)
{
LISTNODE<T>*p=first,*q;
int j=0;
while(p->next!=0&&j<i-1)
{
j++;
p=p->next;
}
if(p->next==0||i<1)
{
//cerr<<"no this position!"<<endl;
return false;
}
else
{
q=p->next;
p->next=q->next;
if(p->next==0)
last=p;
delete q;
}
return true;
}
template<class T>
T LIST<T>::GetPrivor(const T&x)const
{
LISTNODE<T>*p=first;
while(p->next!=0&&p->next->data!=x)
p=p->next;
if(p->next==0||p==first)
return 0;
else return p->data;
}
template<class T>
T LIST<T>::GetNext(const T&x)const
{
LISTNODE<T>*p=first->next;
while(p!=0&&p->data!=x)
p=p->next;
if(p==0||p->next==0)
return 0;
else return p->next->data;
}
template<class T>
LISTNODE<T>*LIST<T>::Find(const T&x)
{
LISTNODE<T>*p=first->next;
while(p!=0&&p->data!=x)
p=p->next;
return p;
}
template<class T>
T LIST<T>::GetData(const int i)const
{
LISTNODE<T>*p=first->next;
int j=0;
while(p!=0&&j<i)
{
j++;
p=p->next;
}
if(p!=0&&j==i)
return p->data;
else return 0;
}
/*template<class T>
void LIST<T>::CreateList()
{
T data;
cout<<"Please input the data:";
cin>>data;
LISTNODE<T> *p=new LISTNODE<T>(data);
p->next=first->next;
first->next=p;
last=p;
cout<<"please input the data:";
while(cin>>data)
{
LISTNODE<T> *q=new LISTNODE<T>(data);
q->next=first->next;
first->next=q;
cout<<"Please input the data:";
}
}*/
#endif

#include<iostream.h>
#include "LIST.H"

template<class T>
LIST<T>::LIST()
{
last=first=new LISTNODE<T>(0);
}
template<class T>
LIST<T>::LIST(const T&x)
{
last=first=new LISTNODE<T>(x);
}
template<class T>
LIST<T>::~LIST()
{
MakeEmpty();
delete first;
last=first=0;
}
template<class T>
void LIST<T>::MakeEmpty()
{
LISTNODE<T> *q;
while(first->next!=0)
{
q=first->next;
first->next=q->next;
delete q;
}
last=first;
}
template<class T>
bool LIST<T>::Insert(const T& x,const int i)
{
LISTNODE<T>*p=first;
int k=0;
int j=0;
while(p!=0&&k<i-1)
{
k++;
p=p->next;
}
if(p==0||i<1)
{
//cerr<<"no this position"<<endl;
return false;
}
else
{
LISTNODE<T>*newnode=new LISTNODE<T>(x);
newnode->next=p->next;
if(p->next==0)
last=newnode;
p->next=newnode;
}
return true;
}
template<class T>
int LIST<T>::Length()const
{
LISTNODE<T>*p=first->next;
int i=0;
while(p!=0)
{
p=p->next;
i++;
}
return i;
}
template<class T>
void LIST<T>::Print()const
{
LISTNODE<T> *p=first;
while(p!=0)
{
cout<<p->data<<" ";
p=p->next;
}
//cout<<endl;
}
template<class T>
bool LIST<T>::Remove(const int i)
{
LISTNODE<T>*p=first,*q;
int j=0;
while(p->next!=0&&j<i-1)
{
j++;
p=p->next;
}
if(p->next==0||i<1)
{
//cerr<<"no this position!"<<endl;
return false;
}
else
{
q=p->next;
p->next=q->next;
if(p->next==0)
last=p;
delete q;
}
return true;
}
template<class T>
T LIST<T>::GetPrivor(const T&x)const
{
LISTNODE<T>*p=first;
while(p->next!=0&&p->next->data!=x)
p=p->next;
if(p->next==0||p==first)
return 0;
else return p->data;
}
template<class T>
T LIST<T>::GetNext(const T&x)const
{
LISTNODE<T>*p=first->next;
while(p!=0&&p->data!=x)
p=p->next;
if(p==0||p->next==0)
return 0;
else return p->next->data;
}
template<class T>
LISTNODE<T>*LIST<T>::Find(const T&x)
{
LISTNODE<T>*p=first->next;
while(p!=0&&p->data!=x)
p=p->next;
return p;
}
template<class T>
T LIST<T>::GetData(const int i)const
{
LISTNODE<T>*p=first->next;
int j=0;
while(p!=0&&j<i)
{
j++;
p=p->next;
}
if(p!=0&&j=i)
return p->data;
else return 0;
}

拿這個改改吧

㈦ 求農歷公歷轉換演算法

編程不太懂
傳下來 口訣

乘五除四九加日
雙月間隔三十天。
一二自加整少一，
三五七八十尾前。

具體的演算法你可網上找下資料 網路上很多的 我就不多累贅了的

㈧ 平衡二叉樹旋轉的結果是唯一的嗎

平衡二叉樹旋轉的結果不是唯一的，具體見下面分析：

插入序列：12, 4, 1, 7, 8, 10, 9, 2, 11, 6, 5

1、先插入12成為根

2、插入4在12的左子樹，沒有旋轉

3、插入1在4的左子樹，以4為中心向右單旋轉，結果如下：

4

/

1 12

4、插入7在12的左子樹，沒有旋轉

5、插入8在7的右子樹，以8開始先左後右雙旋轉，結果如下：

4

/

1 8

/

7 12

6、插入10在12左子樹，以8為中心開始向左單旋轉，結果如下：

8

/

4 12

/ /

1 7 10

7、插入9在10 的左子樹，以10為中心向右單旋轉，結果如下：

8

/

4 10

/ /

1 7 9 12

8、插入2在1的右子樹，沒有旋轉

9、插入11在12 的左子樹，沒有旋轉

10、插入6在7的左子樹，沒有旋轉

11、插入5在6的左子樹，以6為中心向右單旋轉，結果如下：

8

/

4 10

/ /

1 6 9 12

/ /

2 5 7 11