带索引的二叉搜索树

带索引的二叉搜索树

//file:indexedBSTree.h

#pragma once

#include "BSTree.h"

template

class IndexedBSTree : public BSTree

{

public:

void Create();

bool Search(const K& k,E& e)const;

bool IndexSearch(int k,E& e)const;

IndexedBSTree& Insert(const E& e);

IndexedBSTree& Delete(const K& k,E& e);

IndexedBSTree& IndexDelete(int k,E& e);

void Ascend();

void IndexOutput();

private:

static void OutputLeftSize(BinaryTreeNode *t);

};

template

void IndexedBSTree::Create()

{//产生一个空的带索引的二叉搜索树

root = 0;

}

template

bool IndexedBSTree::Search(const K& k,E& e) const

{//将关键值为k的元素返回到e中；如果操作失败返回false，否则返回true return BSTree::Search(k,e);

}

template

bool IndexedBSTree::IndexSearch(int k,E& e) const

{//将第k个元素返回到e中

if(!root)

return false;

BinaryTreeNode *p = root;

while(p)

{

if(k < p->LeftSize)

p = p->LeftChild;

else if(k > p->LeftSize)

{

k -= p->LeftSize;

p = p->RightChild;

}

else

{

e = p->data;

return true;

}

}

return false;

}

template

IndexedBSTree& IndexedBSTree::Insert(const E& e)

{

BSTree::Insert(e);

BinaryTreeNode *t = root;

while(t)

{

if(e < t->data)

{

t->LeftSize++;

t = t->LeftChild;

}

else if(e > t->data)

t = t->RightChild;

else

{

t->LeftSize = 1;

return *this;

}

}

}

template

IndexedBSTree& IndexedBSTree::Delete(const K& k,E& e) {//删除关键值为k的元素并且将其返回到e中

//将p指向关键值为k的节点

BinaryTreeNode *p = root,//搜索指针

*pp = 0;//p的父节点指针

while(p && p->data != k)

{//移动到p的孩子

pp = p;

if(k < p->data)

{

p = p->LeftChild;

}

else

p = p->RightChild;

}

if(!p)

throw BadInput();//没有关键值为k的元素

e = p->data;//保存欲删除的元素

BinaryTreeNode *t = root;//搜索指针

while(t && t->data != k)

{//移动到p的孩子

if(k < t->data)

{

t->LeftSize--;

t = t->LeftChild;

}

else

t = t->RightChild;

}

//对树进行重构

//处理p有两个孩子的情形

if(p->LeftChild && p->RightChild)

{//两个孩子

//转换成有0或1个孩子的情形

//在p的左子树中寻找最大元素

BinaryTreeNode *s = p->LeftChild,*ps = p;//s的父节点while(s->RightChild)

{//移动到较大的元素

ps = s;

s = s->RightChild;

}

p->LeftSize = p->LeftSize - 1;//修改所删除元素的索引值

//将最大元素从s移动到p

p->data = s->data;

p = s;

pp = ps;

}

//p最多有一个孩子

//在c中保存孩子指针

BinaryTreeNode *c;

if(p->LeftChild)

c = p->LeftChild;

else

c= p->RightChild;

//删除p

if(p == root)

root = c;

else

{//p是pp的左孩子还是pp的右孩子？

if(p == pp->LeftChild)

{

pp->LeftChild = c;

}

else

pp->RightChild = c;

}

delete p;

return *this;

}

template

IndexedBSTree& IndexedBSTree::IndexDelete(int k,E& e) {//删除第k个元素并将其返回到e中

BinaryTreeNode *p = root,

*pp = 0;//指向第k个元素的父节点

//寻找删除点

while(p && k != p->LeftSize)

{

pp = p;

if(k < p->LeftSize)

{

p = p->LeftChild;

}

else if(k > p->LeftSize)

{

k -= p->LeftSize;

p = p->RightChild;

}

}

if(!p)

throw BadInput();//没有关键值为k的元素

e = p->data;//保存欲删除的元素

//调整LeftSize值

BinaryTreeNode *t = root;//搜索指针

while(p && k != t->LeftSize)

{//移动到t的孩子

if(k < t->LeftSize)

{

t = t->LeftChild;

}

else if(k > p->LeftSize)

{

k -= t->LeftSize;

t = t->RightChild;

}

}

//对树进行重构

//处理p有两个孩子的情形

if(p->LeftChild && p->RightChild)

{//两个孩子

//转换成有0或1个孩子的情形

//在p的左子树中寻找最大元素

BinaryTreeNode *s = p->LeftChild,*ps = p;//s的父节点while(s->RightChild)

{//移动到较大的元素

ps = s;

s = s->RightChild;

}

p->LeftSize = p->LeftSize - 1;//修改所删除元素的索引值

//将最大元素从s移动到p

p->data = s->data;

p = s;

pp = ps;

}

//p最多有一个孩子

//在c中保存孩子指针

BinaryTreeNode *c;

if(p->LeftChild)

c = p->LeftChild;

else

c= p->RightChild;

//删除p

if(p == root)

root = c;

else

{//p是pp的左孩子还是pp的右孩子？

if(p == pp->LeftChild)

{

pp->LeftChild = c;

}

else

pp->RightChild = c;

}

delete p;

return *this;

}

template

void IndexedBSTree::Ascend()

{//按照关键值的升序排列输出所有元素

InOutput();

}

template

void IndexedBSTree::IndexOutput()

{//中序遍历，输出节点元素的索引值

InOrder(OutputLeftSize,root);

cout<

}

template

void IndexedBSTree::OutputLeftSize(BinaryTreeNode *t) {//输出节点元素的索引值

cout<LeftSize<<' ';

}

//file:BSTree.h

#pragma once

#include "binaryTree.h"

template

class BSTree : public BinaryTree

{

public:

bool Search(const K& k,E& e)const;

BSTree& Insert(const E& e);

BSTree& Delete(const K& k,E& e);

void Ascend() {InOutput();}

void traversalBSTree(int a[]);

void traversalBSTree0(BinaryTreeNode *t,int &pos,int a[]);

BSTree& DeleteMax(E& x);

};

template

bool BSTree::Search(const K& k,E& e) const

{//搜索与k匹配的元素

//指针p从树根开始进行查找

if(!root)

return false;

BinaryTreeNode *p = root;

while(p)//检查p->data

{

if(k < p->data)

p = p->LeftChild;

else if(k > p->data)

p = p->RightChild;

else

{

e = p->data;

return true;

}

}

return false;

}

template

BSTree& BSTree::Insert(const E& e)

{//如果不出现重复，则插入e

BinaryTreeNode *p = root,//搜索指针

*pp = 0;

//寻找插入点

while(p)

{//检查p->data

pp = p;

//将p移向孩子节点

if(e < p->data)

p = p->LeftChild;

else if(e > p->data)

p = p->RightChild;

else

throw BadInput();//出现重复

}

//为e建立一个节点，并将该节点连接至pp

BinaryTreeNode *r = new BinaryTreeNode (e);

if(root)

{//树非空

if(e < pp->data)

pp->LeftChild = r;

else

pp->RightChild = r;

}

else//插入到空树

root = r;

return *this;

}

template

BSTree& BSTree::Delete(const K& k,E& e) {//删除关键值为k的元素，并将其放入e

//将p指向关键值为k的节点

BinaryTreeNode *p = root,//搜索指针

*pp = 0;//p的父节点指针

while(p && p->data != k)

{//移动到p的孩子

pp = p;

if(k < p->data)

else

p = p->RightChild;

}

if(!p)

throw BadInput();//没有关键值为k的元素

e = p->data;//保存欲删除的元素

//对树进行重构

//处理p有两个孩子的情形

if(p->LeftChild && p->RightChild)

{//两个孩子

//转换成有0或1个孩子的情形

//在p的左子树中寻找最大元素

BinaryTreeNode *s = p->LeftChild,*ps = p;//s的父节点while(s->RightChild)

{//移动到较大的元素

ps = s;

s = s->RightChild;

}

//将最大元素从s移动到p

p->data = s->data;

p = s;

pp = ps;

}

//p最多有一个孩子

//在c中保存孩子指针

BinaryTreeNode *c;

if(p->LeftChild)

c = p->LeftChild;

else

c= p->RightChild;

//删除p

if(p == root)

root = c;

else

{//p是pp的左孩子还是pp的右孩子？

if(p == pp->LeftChild)

pp->LeftChild = c;

else

}

delete p;

return *this;

}

template

void BSTree::traversalBSTree(int a[])

{

int pos = 0;

traversalBSTree0(root,pos,a);

}

template

void BSTree::traversalBSTree0(BinaryTreeNode *t,int &pos,int a[]) {

if (!t)

return;

traversalBSTree0(t->LeftChild, pos, a);

a[pos++] = t->data;

traversalBSTree0(t->RightChild, pos, a);

}

template

BSTree& BSTree::DeleteMax(E& x)

{

if (!root)

throw OutOfBounds();

BinaryTreeNode *p = root,

*pp = 0;

while (p->RightChild)

{

pp = p;

p = p->RightChild;

}

x = p->data;

if (p == root)

root = p->LeftChild;

else

pp->RightChild = p->LeftChild;

delete p;

return *this;

}

//file:binaryTree.h

#ifndef _BINARYTREE_H_

#define _BINARYTREE_H_

#include "BinaryTreeNode.h"

#include "linkedQueue.h"

#include "exception.h"

int _count = 0;

template

class BinaryTree

{

template

friend class IndexedBSTree;

template

friend class BSTree;

public:

BinaryTree() {root = 0;}

~BinaryTree() {}

bool IsEmpty() const {return ((root) ? false : true);}

bool Root(T& x) const;

void SetRoot(BinaryTreeNode* t) {root = t;}

BinaryTreeNode* GetRoot() {return root;}

void MakeTree(const T& element,BinaryTree& left,BinaryTree& right);

void BreakTree(T& element,BinaryTree& left,BinaryTree& right);

void PreOrder(void (*Visit)(BinaryTreeNode *u))

{PreOrder(Visit,root);}

void InOrder(void (*Visit)(BinaryTreeNode *u))

{InOrder(Visit,root);}

void PostOrder(void (*Visit)(BinaryTreeNode *u))

{PostOrder(Visit,root);}

void LevelOrder(void (*Visit)(BinaryTreeNode *u));

void PreOutput()

{PreOrder(Output,root);cout<

void InOutput()

{InOrder(Output,root);cout<

void PostOutput()

{PostOrder(Output,root);cout<

void LevelOutput()

{LevelOrder(Output);cout<

void Delete()

{PostOrder(Free,root);root = 0;}

int Height() const

{return Height(root);}

int Size();

BinaryTreeNode* search(T element) {return search(element, root);}

BinaryTreeNode* copy(BinaryTreeNode * t);

int NumLeaves()

{return CountLeaf(root);}

void Swap()

{Swap0(root);}

bool Compare(BinaryTree& X)

{return Compare1(root,X.root);}

bool IsHBLT()

{return IsHBLT(root);}

private:

BinaryTreeNode *root;//根节点指针

void PreOrder(void (*Visit)(BinaryTreeNode *u),BinaryTreeNode *t);

void InOrder(void (*Visit)(BinaryTreeNode *u),BinaryTreeNode *t);

void PostOrder(void (*Visit)(BinaryTreeNode *u),BinaryTreeNode *t);

static void Output(BinaryTreeNode *t);

static void Free(BinaryTreeNode *t) {delete t;}

int Height(BinaryTreeNode *t) const;

static void Add1(BinaryTreeNode *t) {_count++;}

//int Count(BinaryTreeNode *t) const;

BinaryTreeNode* search(T& element,BinaryTreeNode *t);

int CountLeaf(BinaryTreeNode *t);

void Swap0(BinaryTreeNode *t);

bool Compare1(BinaryTreeNode *p,BinaryTreeNode *t);

bool IsHBLT(BinaryTreeNode * t);

};

template

bool BinaryTree::Root(T& x) const

{//取根节点的data域，放入x

//如果没有根节点，则返回false

if(root)

{

x = root->data;

return true;

}

else

return false; //没有根节点

}

template

void BinaryTree::MakeTree(const T& element,BinaryTree& left,BinaryTree& right) {//将left，right和element合并成一棵新树

//left，right和this必须是不同的树

//创建新树

root = new BinaryTreeNode (element,left.root,right.root);

//阻止访问left和right

left.root = right.root = 0;

}

template

void BinaryTree::BreakTree(T& element,BinaryTree& left,BinaryTree& right) {//left，right和this必须是不同的树

//检查树是否为空

if(!root) throw BadInput(); //空树

//分解树

element = root->data;

left.root = root->LeftChild;

right.root = root->RightChild;

delete root;

root = 0;

}

template

void BinaryTree::LevelOrder(void (*Visit)(BinaryTreeNode *u))

{//逐层遍历

LinkedQueue*> Q;

BinaryTreeNode *t;

t = root;

while(t)

{

Visit(t);

if(t->LeftChild)

Q.Add(t->LeftChild);

if(t->RightChild)

Q.Add(t->RightChild);

try{Q.Delete(t);}

catch (OutOfBounds){return ;}

}

}

template

int BinaryTree::Size()

{

_count = 0;

PreOrder(Add1,root);

return _count;

}

/*int size(){

return Count(root);

}*/

template

BinaryTreeNode* BinaryTree::copy(BinaryTreeNode * t) {

if (!t)

return 0;// empty tree

BinaryTreeNode * left = copy(t->LeftChild);

BinaryTreeNode * right = copy(t->RightChild);

root = new BinaryTreeNode ;

root->data = t->data;

root->LeftChild = left;

root->RightChild = right;

return root;

}

/*

template

bool BinaryTree::Compare(BinaryTree& X)

{//比较该二叉树与二叉树X

BinaryTreeNode *t = X.GetRoot();

return Compare1(root,t);

}

*/

//**********************************私有函数成员*******************************************

template

void BinaryTree::PreOrder(void (*Visit)(BinaryTreeNode *u),BinaryTreeNode *t) {//前序遍历

if(t)

{

Visit(t);

PreOrder(Visit,t->LeftChild);

PreOrder(Visit,t->RightChild);

}

}

template

void BinaryTree::InOrder(void (*Visit)(BinaryTreeNode *u),BinaryTreeNode *t) {//中序遍历

if(t)

{

InOrder(Visit,t->LeftChild);

Visit(t);

InOrder(Visit,t->RightChild);

}

}

template

void BinaryTree::PostOrder(void (*Visit)(BinaryTreeNode *u),BinaryTreeNode *t) {//后序遍历

if(t)

{

PostOrder(Visit,t->LeftChild);

PostOrder(Visit,t->RightChild);

Visit(t);

}

}

template

void BinaryTree::Output(BinaryTreeNode *t)

{

cout<data<<' ';

}

template

int BinaryTree::Height(BinaryTreeNode *t) const

{//返回树*t的高度

if(!t)

return 0; //空树

int hl = Height(t->LeftChild);//左子树的高度

int hr = Height(t->RightChild);//右子树的高度

if(hl > hr)

return ++hl;

else

return ++hr;

}

/*

template

int BinaryTree::Count(BinaryTreeNode *t) const

{

if (!t) return 0;

int left,right;

left = Count(t->LeftChild);

right = Count(t->RightChild);

return 1 + left + right;

}

*/

template

BinaryTreeNode* BinaryTree::search(T& element,BinaryTreeNode *t) {

if (!t)

return 0;

if(t->data == element)

return t;

BinaryTreeNode * p;

p = search(element, t->LeftChild);

if(p)

return p;

return search(element, t->RightChild);

}

template

int BinaryTree::CountLeaf(BinaryTreeNode *t)

{

if(!t)

return 0;

if(!t->LeftChild && !t->RightChild)

return 1;

int c1,c2;

c1 = CountLeaf(t->LeftChild);

c2 = CountLeaf(t->RightChild);

return c1 + c2;

}

template

void BinaryTree::Swap0(BinaryTreeNode *t)

{//交换二叉树所有节点的左右子节点

if(t)

{

if(t->LeftChild || t->RightChild)

{

BinaryTreeNode *temp = t->LeftChild;

t->LeftChild = t->RightChild;

t->RightChild = temp;

}

Swap0(t->LeftChild);

Swap0(t->RightChild);

}

}

template

bool BinaryTree::Compare1(BinaryTreeNode *p,BinaryTreeNode *t) {

if(!p && !t)

return true;

if((!p && t) || (p && !t))

return false;

if(p && t)

{

if(p->data == t->data)

{

bool left = Compare1(p->LeftChild,t->LeftChild);

bool right = Compare1(p->RightChild,t->RightChild);

if(left && right)

return true;

else

return false;

}

else

return false;

}

}

template

bool BinaryTree::IsHBLT(BinaryTreeNode * t)

{

if(!t)

return true;

if(!t->LeftChild && t->RightChild)

return false;

if(t->LeftChild && !t->RightChild)

return true;

bool bLeft = IsHBLT(t->LeftChild);

bool bRight = IsHBLT(t->RightChild);

if(bLeft && bRight)

return true;

else

return false;

}

//***************************************************************************** **************

#endif

//file:binaryTreeNode.h

#ifndef _BINARYTREENODE_H_

#define _BINARYTREENODE_H_

#include

using namespace std;

template

class BinaryTree;

template

class BinaryTreeNode

{

template

friend class IndexedBSTree;

template

friend class BSTree;

friend class BinaryTree;

friend ostream& operator<<(ostream& out,BinaryTreeNode *p);

BinaryTreeNode()

{

LeftChild = RightChild = 0;

}

BinaryTreeNode(const T& e)

{

data = e;

LeftChild = RightChild = 0;

}

BinaryTreeNode(const T& e,BinaryTreeNode *l,BinaryTreeNode *r)

{

data = e;

LeftChild = l;

RightChild = r;

}

T GetData(){return data;}

void SetLeftChild(BinaryTreeNode *left) {LeftChild = left;}

void SetRightChild(BinaryTreeNode *right) {RightChild = right;} private:

T data;

BinaryTreeNode *LeftChild,//左子树

*RightChild;//右子树

int LeftSize;//索引值= 该节点左子树的元素个数加1

};

template

ostream& operator<<(ostream& out,BinaryTreeNode *p)

{

out<GetData()<

return out;

}

#endif

//file:linkedQueue.h

#ifndef _LINKEDQUEUE_H_

#define _LINKEDQUEUE_H_

#include "node.h"

#include "exception.h"

template

class LinkedQueue

public:

LinkedQueue() {front = rear = 0;}//构造函数

~LinkedQueue();//析构函数

bool IsEmpty() const

{return ((front) ? false : true);}

bool IsFull() const;

T First() const;//返回第一个元素

T Last() const;//返回最后一个元素

Node* GetFront(){return front;}

LinkedQueue& Add(const T& x);

LinkedQueue& Delete(T& x);

private:

Node *front;//指向第一个节点

Node *rear;//指向最后一个节点

};

template

LinkedQueue::~LinkedQueue()

{//队列析构函数，删除所有节点

Node *next;

while(front)

{

next = front->link;

delete front;

front = next;

}

}

template

bool LinkedQueue::IsFull() const

{//判断队列是否已满

Node *p;

try

{

p = new Node;

delete p;

return false;

}

catch(NoMem)

{return true;}

}

template

T LinkedQueue::First() const