动态查找表的特点是表结构本身是在查找过程中动态生成的。二叉排序树的定义是：或者是一颗空树，或者是具有下列性质的二叉树：（1）若它的左子树不空，则左子树上所有结点的值均小于它的根节点的值；（2）若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；（3）它的左右子树也分别是二叉排序树。可以用二叉链表作为二叉排序树的存储结构。程序实现如下：

/*****************************静态查找表的建立及顺序查找操作******************************/
//by vipper.zhang 2011.7.11 如果有什么问题或者可以改进的建议，请发邮件至vipper.zhang@gmail.com 
//O(∩_∩)0

#include <iostream>

using namespace std;
typedef int KeyType;

//二叉链表存储二叉查找树结点
typedef struct BSTNode{
	KeyType key;
    BSTNode *lchild,*rchild;
}*BSTree;

//查找元素
bool SearchBST(BSTree bst,KeyType key,BSTree f,BSTree &p)   //f为bst双亲，p返回等于key的结点
{
   if(!bst) 
   {
	   p=f;
	   return false;
   }
   else if((bst->key)==key) 
   {
	   p=bst;
	   return true;
   }
   else if((bst->key) >key)  return SearchBST(bst->lchild,key,bst,p);
   else if((bst->key) <key)  return SearchBST(bst->rchild ,key,bst,p);
}


//插入元素
bool InsertBST(BSTree &bst,KeyType key)
{
	BSTree p=new BSTNode;
    if(!SearchBST(bst,key,NULL,p))
	{

		BSTree s=new BSTNode();
		s->key =key;
		s->lchild =s->rchild =NULL;
		if(!p) bst=s;
		else if(key< p->key)
			p->lchild=s;
		else if(key>p->key)
			p->rchild=s;
		return true;
	} 
	return false;
}

//创建二叉排序树
void CreateBST(BSTree &bst)
{ 
	
   KeyType key;
   while (cin>>key)
   {
	   if(key==-1)
		   break;
	   else
		   InsertBST(bst,key);
   }
}

BSTree GetFather(BSTree bst,BSTree p)
{
	if(bst==NULL||p==bst)
		return NULL;
	else if(bst->lchild ==p||bst->rchild==p)
		return bst;
	else if(bst->key <p->key)
	{
      GetFather(bst->rchild ,p);
	}
	else if(bst->key >p->key )
		GetFather(bst->lchild ,p);
}

//删除结点
bool DeleteBST(BSTree &bst,KeyType key)
{
	BSTree p,q,s,f;
	p=bst;
	if(!bst)
	{
		cout<<"bst tree does not exit"<<endl;
		return false;
	}
	do                //找到关键字所在结点p
	{
	if(p->key==key)
	{    
        break;
	}
	else if(bst->key >key)
		p=p->lchild ;
	else if(bst->key <key)
		p=p->rchild;
	}while(p);
    
	if(p==NULL)
	{
        cout<<"no such element "<<endl;
		return false;
	}
	else{
		f=GetFather(bst,p);              //找到p结点的父亲结点

		
		if(!p->lchild&&(!p->rchild)&&f!=NULL)    //p是叶子结点, 且不是根结点
		{
			if(f->lchild ==p)
			{
				delete p;
				f->lchild =NULL;
			}
			else
			{
				delete p;
				f->rchild =NULL;
			}
			return true;
		}
		if(!p->lchild && !p->rchild && f==NULL)   //p是叶子结点, 且是根结点
		{
			bst=NULL;
            delete p;

            return true;
		}
			
		if(!p->lchild&&f!=NULL)                  //p左孩子为空结点,且不是根结点
		{  
            q=p;
			p=p->rchild;
            delete  q;
			
			f->rchild =p;
			return true;
		}

		if(!p->lchild&&f==NULL)                  //p左孩子为空结点,且p是根结点
		{  
            q=p;
			p=p->rchild;
			bst=p;
            delete  q;
			return true;
			
		}
         
		if(!p->rchild&&f!=NULL)                 //p右孩子为空结点,且不是根结点
		{ 
			q=p;
			p=p->lchild ;
			delete q;
			
			f->lchild =p;
			return true;
		}

        if(!p->rchild&&f==NULL)                 //p右孩子为空结点,且是根结点
		{ 
			q=p;
			p=p->lchild ;
			bst=p;
  			delete q;
			return true;
			
		}

		else if(p->lchild &&p->rchild )    //p的两个子树都不空
		{
			q=p;
            s=p->lchild ;
			while(s->rchild){q=s;s=s->rchild ;}
			p->key =s->key ;
			if(q!=p)
				q->rchild =s->lchild ;
			else
				q->lchild =s->lchild ;
			delete s;
			
		}
		
	}
    return true;
}

//中序遍历并输出所有结点
void PrintBST(BSTree bst)
{
  if(!bst)
	  cout<<"n\t";
  else 
  {
     PrintBST(bst->lchild);
	 cout<<bst->key<<"\t";
	 PrintBST(bst->rchild); 
  }
}



int main()
{
	BSTree bst=new BSTNode;       //查了半天错误，原来是没有为其分配内存，导致读取内存错误
	bst->key=0;
	bst->lchild=bst->rchild =NULL; 
	 
	cout<<"input the element of the bst, -1 finish : "<<endl;
 	CreateBST(bst);
	PrintBST(bst); cout<<endl;

    DeleteBST(bst,6);
    PrintBST(bst); cout<<endl;
	//BSTree f=GetFather(bst,bst->rchild ->rchild );
	//cout<<f->key<<" "<<endl;

	system("pause");
	return 0;
	
}

测试用例：1  2 3 4 5 6 7 -1

                    5  3  2  4  6  7 -1