双转算法

㈠ 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