数据结构与算法（第三章-2）

目录

一、二叉查找树

1.定义：

2.实现：

二、堆与优先队列 

用数组存储完全二叉树

---

一、二叉查找树

1.定义：

  空树||满足以下条件：

（1）若左子树非空，左子树所有节点的值小于根节点；

（2）若右子树非空，右子树所有节点的值大于根节点；

（3）左右子树均是二叉查找树。

二叉查找树不存在关键值相等的节点，二叉排序树中允许存在关键值相等的节点，习惯将相等的节点放在其右子树中。

2.实现：

template <class T>
class BSTree:public BTree <T>
{
public:
	BSTree(){BTree<T>();}
	~BSTree(){~BTree<T>();}
	BTNode<T>*Search(BTNode<T>*&r,const T&e)
	{
	    if(r==NULL)
	    return NULL ;
	    else if(r->value()>e)
	    return Search(r->left,e);
	    else if(r->value()<e)
	   	return Search(r->right,e);	
	   	else
	   	return r;
	}
	void Insert(BTNode<T>*&r,const T&e)
	{
		if(r==NULL)
		{
		    r=new BTNode<T>(e);
		    return;
		}
		else if(r->value()==e)
		return;
		else if(r->value()>e)
		Insert(r->left,e);
		else if(r->value()<e)
		Insert(r->right,e);
    }
	bool Delete(BTNode<T>*&r,const T&e)
	{
		BTNode<T>*pointer=Search(r,e);
		if(pointer==NULL) return false;
		BTNode<T>*ptr=pointer;
		BTNode<T>*child,*p=BTree<T>::Parent(pointer);
		if(pointer->left&&pointer->right)
		{
			p=pointer;
			pointer=p->right;
			while(pointer->left)
			{
				p=pointer;
				pointer=pointer->left;
			}
		}
		child=(pointer->left)?pointer->left:pointer->right;
		if(p==NULL)
		r=child;
		else
		{
		    if(p->left==pointer) p->left=child;
		    else p->right=child;
		}
		if(ptr!=pointer)
		ptr->value()=pointer->value();
		delete pointer;
		return true;
	}
};

BTree中应该增加：

	BTNode<T>* visit (BTNode<T>*p,BTNode<T>*c)
	{
		if(p->left==c||p->right==c)
	    return p;
	    else
	    return visit(p->left,c);
	    return visit(p->right,c);
    }
	BTNode<T>*Parent(BTNode<T>*c)
	{
		BTNode<T>*p=root;
		if(p==c)
		return NULL;
		else 
		return visit(p,c);	
	}

二、堆与优先队列 

用数组存储完全二叉树

#include<iostream>
using namespace std;
template<typename T>
class MaxHeap
{
	T*Heap;
	int n;
	int maxsize;
public:
	MaxHeap(T*data,int num,int max )
	{
		Heap=data;
		n=num;
		maxsize=max;
	}
	~MaxHeap(){delete[]Heap;}
	bool Isleaf(int pos){return pos*2+1>n-1;}
	int Leftch(int pos){return pos*2+1;}
	int Rightch(int pos){return pos*2+2;}
	int Parent(int pos){return (pos-1)/2;}
	void Siftdown(int pos);
	void Buildheap();
	bool Insert(const T& e);
	T& Remove();
};
template<class T>
bool MaxHeap<T>::Insert(const T& e)
{
	if(n==maxsize)
	return false;
	Heap[n]=e;
	int p;
	p=Parent(n);
	while(p>=0&&e>Heap[p])
	{
	    T t;
	    t=Heap[n];
	    Heap[n]=Heap[p];
	    Heap[p]=t;
	    n=p;
	    p=Parent(n);
	}
	return true;
}
template<class T>
void MaxHeap<T>::Siftdown(int pos)
{
	T temp=Heap[pos];
	while(!Isleaf(pos))
	{
		int lc=Leftch(pos);
		if(lc<n-1&&Heap[lc]<Heap[lc+1])
		lc++;
		if(temp>=Heap[lc])
		break;
		Heap[pos]=Heap[lc];
		pos=lc;
	}
	Heap[pos]=temp;
}
template<class T>
void MaxHeap<T>::Buildheap()
{
	for(int i=n/2-1;i>=0;i--)
	Siftdown(i);
}
template<class T>
T& MaxHeap<T>::Remove()
{
	T temp=Heap[0];
	if(--n!=0)
	{
		Heap[0]=Heap[n];
		Siftdown(0); 
	}
	return temp;
}