二分查找--AVL查找树

二分查找可以找到元素在数组中的下标位置，而查找树由于采用的是树结构，所以只能判断出元素是不是在树中以及给出最大/小值，而不能确定指定元素的确切位置。
二分查找

#include<vector>

#include<iostream>

#include<algorithm>

#include<cstdlib>

#include<iomanip>		//cout格式化输出

#include<ctime>

using namespace std;

const int NOT_FOUND=-1;

const long MUL=16807L;

const long ADD=13849;

const long MOD=0x7fffffffL;

//线性同余法产生无符号随机数

inline unsigned myRand(){

static long seed=(long)time(NULL);

seed=(seed*MUL+ADD)%MOD;

return (unsigned)seed>>17;      //linear congruential method高16位随机性比较好,我们只用它的高15位,返回值在[0,32767]

}

template <typename Comparable>

int binarySearch(const vector<Comparable> & a,const Comparable & x){

int low=0;

int high=a.size()-1;

while(low<=high){

int mid=(low+high)/2;

if(x>a[mid])

low=mid+1;

else if(x<a[mid])

high=mid-1;

else

return mid;

}

return NOT_FOUND;

}

int main(){

clock_t begin=clock();

vector<int> v;

for(int i=0;i<1000000;i++)//生成一百万个随机数进行排序

v.push_back((int)myRand());

sort(v.begin(),v.end());

int position=binarySearch(v,20109);

clock_t finish=clock();

long elapse=(long)(finish-begin);

cout<<"find the element in position: "<<position<<endl;

cout<<"elapsed time:"<<setprecision(5)<<(float)elapse/CLOCKS_PER_SEC<<"s"<<endl;

return 0;

}

 
clock_t的值转换为秒应该是除以CLOCKS_PER_SEC这个宏，而这个宏在Windows平台下是1000，而到了Linux平台下就是1000000了
 
AVL查找树

#include<iostream>
#include<iomanip>

using namespace std;

const long MUL=16807L;

const long ADD=13849L;

const long MOD=0x7fffffffL;

//线性同余法产生无符号随机数

inline unsigned myRand(){

static long seed=(long)time(NULL);

seed=(seed*MUL+ADD)%MOD;

return (unsigned)seed>>17;      //linear congruential method高16位随机性比较好,我们只用它的高15位,返回值在[0,32767]

}

//定义平衡二叉树

struct AvlNode{

int element;

AvlNode *left;

AvlNode *right;

int height;

AvlNode(const int & theElement,AvlNode *lt,AvlNode *rt,int h=0):

element(theElement),left(lt),right(rt),height(h){}

};

//计算节点的高度

int height(AvlNode * t){

return t==0?-1:t->height;

}

//返回两个整值的最大者

int max(const int l,const int r){

if(l>r)

return l;

else

return r;

}

//左旋

void rotateWithLeftChild(AvlNode * & k2){

AvlNode *k1=k2->left;

k2->left=k1->right;

k1->right=k2;

k2->height=max(height(k2->right),height(k2->left))+1;

k1->height=max(height(k1->left),k2->height)+1;

k2=k1;

}

//右旋

void rotateWithRightChild(AvlNode * & k2){

AvlNode *k1=k2->right;

k2->right=k1->left;

k1->left=k2;

k2->height=max(height(k2->left),height(k2->right))+1;

k1->height=max(height(k1->right),k2->height)+1;

k2=k1;

}

//左--右旋

void doubleWithRightChild(AvlNode * & k3){

rotateWithLeftChild(k3->right);

rotateWithRightChild(k3);

}

//右--左旋

void doubleWithLeftChild(AvlNode * & k3){

rotateWithRightChild(k3->left);

rotateWithLeftChild(k3);

}

//插入新节点

void insert(const int & x,AvlNode * & t){

if(t==0)

t=new AvlNode(x,0,0);

else if(x<t->element){

insert(x,t->left);

if(height(t->left)-height(t->right)==2){

if(x<t->left->element)

rotateWithLeftChild(t);

else

doubleWithLeftChild(t);

}

}

else if(x>t->element){

insert(x,t->right);

if(height(t->right)-height(t->left)==2){

if(x>t->right->element)

rotateWithRightChild(t);

else

doubleWithRightChild(t);

}

}

else

;//Duplicate;Do nothing

t->height=max(height(t->left),height(t->right))+1;

}

//判断树中是否包含要查找的节点

bool contains(const int & x,AvlNode * t){

if(t==0)

return false;

else if(x<t->element)

return contains(x,t->left);

else if(x>t->element)

return contains(x,t->right);

else

return true;

}

int main(){

clock_t begin=clock();

AvlNode * root=new AvlNode(0,0,0);

for(int i=0;i<1000000;i++)//生成一百万个随机数进行排序

insert((int)myRand(),root);

if(contains(20109,root))

cout<<"find"<<endl;

else

cout<<"not find"<<endl;

clock_t finish=clock();

long elapse=(long)(finish-begin);

cout<<"elapsed time:"<<setprecision(5)<<(float)elapse/CLOCKS_PER_SEC<<"s"<<endl;

return 0;

}

比较结果
生成一百万个随机数，在我的机子上进行查找，运行10次的平均时间（建立存储结构+查找时间）：秒  

二分查找	平衡二叉查找树
0.67	1.11