主要有二叉树,线索二叉树,AVL树,哈夫曼二叉树,二叉查找树(查找那一篇已发,这里不再重复)
二叉树:
//头文件 :
template<class T>
class TreeNode //采用左孩子,右兄弟的链式方式存储
{
private:
T data;
TreeNode<T> *firstChild, *nextBrother;
public:
TreeNode (T value = 0, TreeNode<T> *L = NULL, TreeNode<T> *R = NULL):data(value), firstChild(L), nextBrother(R){}
TreeNode<T> *GetFirstChild()const {return firstChild;}
void SetFirstChild(TreeNode<T> *t) {firstChild = t;}
TreeNode<T> *GetNextBrother() const{return nextBrother;}
void SetNextBrother(TreeNode<T> *t) {nextBrother = t;}
T &GetData() {return data;}
void SetData(const T &item){data = item;}
};
template<class T>
class Tree
{
private:
TreeNode<T> *root;
T stop;
public:
Tree() {root = NULL;}
TreeNode<T> *FindTarget(TreeNode<T> *t, T target);
TreeNode<T> *FindFather(TreeNode<T> *t, TreeNode<T> *p);
TreeNode<T> *FirstChild(TreeNode<T> *p);
TreeNode<T> *NextBrother(TreeNode<T> *p);
void DelSubTree(TreeNode<T> *t, TreeNode<T> *p);
void Del(TreeNode<T> *p);
void PreOder(TreeNode<T> *t);
void NorecPreOrder(TreeNode<T> *t);
void LevelOrder(TreeNode<T> *t);
T GetStop() {return stop;}
void SetStop(T tostop) {stop = tostop;}
TreeNode<T> *GetRoot() {return root;}
void SetRoot(TreeNode<T> *t) {root = t;}
TreeNode<T> *Create();
void CreateTree(T stop);
};
//源文件:
#include "TreeNode.h"
template<class T>
TreeNode<T> * Tree<T>::FindTarget(TreeNode<T> *t, T target)
{
if (t == NULL) return NULL;
TreeNode<T> *result = NULL;
if ((t->GetData()) == target) result t;
else
{
TreeNode<T> *p = t->GetFirstChild();
int i = 0;
while(p != NULL && (result = FindTarget()) == NULL)
p = p->GetNextBrother();
return result;
}
};
template<class T>
TreeNode<T> *Tree<T>::FindFather(TreeNode<T> *t, TreeNode<T> *p)
{
if (t == NULL) return NULL;
TreeNode<T> *result = NULL;
TreeNode<T> *q = t->GetFirstChild();
while(q != NULL && q != p)
{
result = FindFather(q, p);
if (!result) q = q->GetNextBrother();
else
return result;
}
if (q == p) result t;
else
return NULL;
};
template<class T>
TreeNode<T> *Tree<T>::FirstChild(TreeNode<T> *p)
{
if (p != NULL && (p = p->GetFirstChild()) != NULL)
return p->GetFirstChild();
return NULL;
};
template<class T>
TreeNode<T> *Tree<T>::NextBrother(TreeNode<T> *p)
{
if (p != NULL && (p = p->GetNextBrother()) != NULL)
return p->GetNextBrother();
return NULL;
};
template<class T>
void Tree<T>::DelSubTree(TreeNode<T> *t, TreeNode<T> *p)
{
if ( t != NULL && p != NULL)
{
TreeNode<T> *q = NULL, *result = NULL;
result = FindFather(t, p);
if (result)
{
if ((result->GetFirstChild()) == p)
{
result->SetFirstChild(p->GetNextBrother());
Del(p);
return;
}
else
{
q = result->GetFirstChild();
while((q->GetNextBrother()) != p) q = q->GetNextBrother();
q->SetNextBrother(p->GetNextBrother());
Del(p);
return;
}
}
else
{
Del(p);
root = NULL;
}
}
};
template<class T>
void Tree<T>::Del(TreeNode<T> *p)
{
if ( p != NULL)
{
TreeNode<T> *q = p->GetFirstChild(), *next;
while(q != NULL)
{
next = q->GetNextBrother();
Del(q);
q = next;
}
delete p;
}
};
template<class T>
void Tree<T>::PreOder(TreeNode<T> *t)
{
if (t != NULL)
{
cout<<t->GetData()<<endl;
TreeNode<T> *child = NULL;
child = FirstChild(t);
while(child)
{
PreOder(child);
child = NextBrother(child);
}
}
};
template<class T>
void Tree<T>::NorecPreOrder(TreeNode<T> *t)
{
if (t == NULL) return;
AStack<TreeNode<T>*> s;
int i;
TreeNode<T> *p = t;
do
{
while(p != NULL)
{
cout<<p->GetData()<<endl;
s.Push(p);
p = FirstChild(p);
}
while(p == NULL && s.IsEmpty())
{
s.Pop(p);
p = NextBrother(p);
}
} while (!s.IsEmpty());
}
template<class T>
void Tree<T>::LevelOrder(TreeNode<T> *t)
{
AQueue<TreeNode<T> *> q;
if (t != NULL)
{
TreeNode<T> *p;
q.QInsert(t);
while(!q.isEmpty())
{
q.QDelete(p);
cout<<p->GetData()<<endl;
p = FirstChild(p);
while(p != NULL)
{
q.QInsert(p);
p = NextBrother(p);
}
}
}
};
template<class T>
TreeNode<T> *Tree<T>::Create()
{
};
template<class T>
void Tree<T>::CreateTree(T stop)
{
};
//线索二叉树:
//头文件:
template<class T>
class ThreadNode
{
private:
int LThread, RThread; //1为线索 0为左孩子
ThreadNode<T> *left;
ThreadNode<T> *right;
T data;
public:
ThreadNode(const T item):data(item), left(NULL), right(NULL), LThread(0), RThread(0){}
ThreadNode<T> *GetLeft(void) const{return left;}
void SetLeft(ThreadNode<T> *t){left = t;}
ThreadNode<T> *GetRight(void) const{return right;}
void SetRight(ThreadNode<T> *t){right = t;}
T &GetData(){return data;}
void SetData(const T &item) {data = item;}
void SetLThread(const int d){LThread = d;}
int GetLThread() {return LThread;}
void SetRThread(const int d){RThread = d;}
int GetRThread() {return RThread;}
};
template<class T>
class ThreadInTree //中序线索二叉树
{
private:
ThreadNode<T> *root;
T stop;
ThreadNode<T> *pre;
public:
ThreadInTree(ThreadNode<T> *t){root = t;}
ThreadNode<T> *FIO(ThreadNode<T> *t); //返回中序线索二叉树t的中根序列的第一个结点
ThreadNode<T> *LIO(ThreadNode<T> *t); //返回中序线索二叉树t的中根序列的最后一个结点
ThreadNode<T> *PIO(ThreadNode<T> *t, ThreadNode<T> *p); //在以t为根结点的中序线索二叉树中搜索结点p的中根前驱结点
ThreadNode<T> *NIO(ThreadNode<T> *t, ThreadNode<T> *p); //在以t为根结点的中序线索二叉树中搜索结点p的中根后驱结点
void InOrderOf(ThreadNode<T> *t); //中序遍历以结点t为根结点的中序线索二叉树
void InsertLeft(ThreadNode<T> *p, ThreadNode<T> *s);
void InsertRight(ThreadNode<T> *p, ThreadNode<T> *s); //插入一个结点p,作为结点s的右结点
ThreadNode<T> *GetRoot() {return root;}
void SetRoot(ThreadNode<T> *t) {root = t;}
T GetStop() {return stop;}
void SetStop(T tostop) {stop = tostop;}
void CreatThreadingTree(T tostop);
ThreadNode<T> *Create();
void ThreadingTree();
void InThreading(ThreadNode<T> *t);
ThreadNode<T> *First() {return FIO(root);}
ThreadNode<T> *Last() {return LIO(root);}
void InOrder() {InOrderOf(root);}
ThreadNode<T> *search(ThreadNode<T> *t, T item);
void DeleteLeft(ThreadNode<T> *p, ThreadNode<T> *s);
void DeleteRight(ThreadNode<T> *p, ThreadNode<T> *s); //删除结点s的左子结点p
};
//源文件:
#include "ThreadNode.h"
template<class T>
ThreadNode<T> *ThreadInTree<T>::FIO(ThreadNode<T> *t)
{
if (t == NULL) return NULL;
ThreadNode<T> *q = t;
while((q->GetLThread()) == 0)
q = q->GetLeft();
return q;
}
template<class T>
ThreadNode<T> *ThreadInTree<T>::LIO(ThreadNode<T> *t)
{
if (t == NULL) return NULL;
ThreadNode<T> *q = t;
while((q->GetRThread()) == 0)
q = q->GetRight();
return q;
}
template<class T>
ThreadNode<T> *ThreadInTree<T>::PIO(ThreadNode<T> *t, ThreadNode<T> *p)
{
if ( t == NULL || p == NULL) return NULL;
ThreadNode<T> *q;
if (p == FIO(t)) return NULL;
ThreadNode<T> *rp = p->GetLeft();
if((p->GetLThread()) == 1) return rp;
q = LIO(rp);
return q;
}
template<class T>
ThreadNode<T> *ThreadInTree<T>::NIO(ThreadNode<T> *t, ThreadNode<T> *p)
{
if ( t == NULL || p == NULL) return NULL;
ThreadNode<T> *q;
if (p == LIO(t)) return NULL;
ThreadNode<T> *rp = p->GetRight();
if((p->GetRThread()) == 1) return rp;
q = FIO(rp);
return q;
}
template<class T>
void ThreadInTree<T>::InOrderOf(ThreadNode<T> *t)
{
if (t == NULL) return;
ThreadNode<T> *q;
for (q = FIO(t); q != NULL; q = NIO(t, q))
cout<<q->GetData()<<endl;
}
template<class T>
void ThreadInTree<T>::InsertRight(ThreadNode<T> *p, ThreadNode<T> *s)
{
if ( p == NULL || s == NULL) return NULL;
p->SetRight(s->GetRight());
p->SetRThread(s->GetRThread());
p->SetLeft(s);
p->SetLThread(1);
s->SetRight(p);
s->SetRThread(0);
if ((s->GetRThread()) == 0)
{
ThreadNode<T> *q = p->GetRight();
q = FIO(q);
q->SetLeft(p);
}
}
//AVL树:
//头文件:
template<class T>
class AVLNode
{
public:
T key;
AVLNode<T> *llink;
AVLNode<T> *rlink;
int balance;
int RANK;
AVLNode(const T &item, AVLNode<T> *lptr = NULL, AVLNode<T> *rptr = NULL):key(item), llink(lptr), rlink(rptr), balance(0){}
};
template<class T>
class AVLTree
{
private:
AVLNode<T> *head;
T stop;
AVLNode<T> **link(int a, AVLNode<T> *p);
public:
AVLTree();
AVLNode<T> *Search_Insert(T k);
AVLNode<T> *SearchByPos(int k);
void InsertByPos(int k, AVLNode<T> *q);
AVLNode<T> *GetRoot() {return head->rlink;}
void InOrder(AVLNode<T> *t) const;
T GetStop() {return stop;}
void SetStop(T tostop) {stop = tostop;}
};
//源文件:
#include "AVLNode.h"
template<class T>
AVLNode<T> ** AVLTree<T>::link(int a, AVLNode<T> *p)
{
if (a == -1) return (&(p->llink));
if (a == 1) return (&(p->rlink));
return NULL;
};
template<class T>
AVLNode<T> *AVLTree<T>::Search_Insert(T k)
{
int a;
AVLNode<T> *t = head;
AVLNode<T> *s = head->rlink;
AVLNode<T> *p = head->rlink;
AVLNode<T> *q;
if (s == NULL)
{
q = new AVLNode<T>(k);
head->rlink = q;
head->llink = 0;
return NULL;
}
while(true)
{
if (k == p->key) return p;
if(k < p->key)
{
q = p->llink;
if (q == NULL)
{
q = new AVLNode<T>(k);
p->llink = q;
break;
}
else
{
if (q->balance != 0)
{
t = p;
s = q;
}
p = q;
}
}
else
{
q = p->rlink;
if (q == NULL)
{
q = new AVLNode<T>(k);
p->rlink = q;
break;
}
else
{
if (q->balance != 0)
{
t = p;
s = q;
}
p = q;
}
}
}
//插入完成,下面调整平衡系数
if (k < s->key) a = -1;
else a = 1;
AVLNode<T> *r = *link(a, s);
p = r;
while(p != q)
{
if (k < p->key)
{
p->balance = -1;
p = p->llink;
}
if (k > p->key)
{
p->balance = 1;
p = p->rlink;
}
}
if (s->balance == 0)
{
s->balance = a;
head->llink = head->llink+1;
return NULL;
}
else if(s->balance == -a)
{
s->balance = 0;
return NULL;
}
else if (s->balance == a)
{
if (r->balance == a)
{
p = r;
*link(a, s) = *link(-a, r);
*link(-a, r) = s;
s->balance = 0;
r->balance = 0;
}
else if (r->balance == -a)
{
p = *link(-a, r);
*link(a, r) = *link(a, p);
*link(a, p) = r;
*link(a, s) = *link(-a, p);
*link(-a, p) = s;
if (p->balance == a)
{
s->balance = -a;
r->balance = 0;
}
if (p->balance == 0)
{
s->balance = 0;
r->balance = 0;
}
if (p->balance == -a)
{
s->balance = 0;
r->balance = a;
}
p->balance = 0;
}
if (s == t->rlink) t->rlink = p;
else t->llink = p;
}
return NULL;
};
template<class T>
AVLNode<T> *AVLTree<T>::SearchByPos(int k)
{
int m = k;
AVLNode<T> *p = head->rlink;
while()
{
if(m == p->RANK)return p;
else if (m < p->RANK) p = p->llink;
else
{
m -= p->RANK;
p = p->rlink;
}
}
return NULL;
};
template<class T>
void AVLTree<T>::InsertByPos(int k, AVLNode<T> *q)
{
AVLNode<T> *t = head;
AVLNode<T> *s = head->rlink;
AVLNode<T> *p = head->rlink;
AVLNode<T> *r;
int a;
int u, m;
u = k;
m = k;
while(true)
{
if (m <= p->RANK)
{
p->RANK ++;
r = p->llink;
if (r == NULL)
{
p->llink = q;
break;
}
else
{
if (r->balance != 0)
{
t = p;
s = r;
u = m;
}
p = r;
}
}
else
{
m -= p->RANK;
r = p->rlink;
if (r == NULL)
{
p->rlink = q;
break;
}
else
{
if (r->balance != 0)
{
t = p;
s = r;
u = m;
}
p = r;
}
}
}
//插入
q->RANK = 1;
q->llink = NULL;
q->rlink = NULL;
q->balance = 0;
//调整平衡系数
m = u;
if (m < s->RANK)
{
r = s->llink;
p = r;
a = -1;
}
else
{
r = s->rlink;
p = r;
a = 1;
m -= s->RANK;
}
while(p != q)
{
if (m < p->RANK)
{
p->balance = -1;
p = p->llink;
}
if(m > p->RANK)
{
p->balance = 1;
m -= p->RANK;
p = p->rlink;
}
}
if (s->balance == 0)
{
s->balance = a;
head->llink = head->llink + 1;
return;
}
if(s->balance == -a)
{
s->balance = 0;
return;
}
if (s->balance == a)
{
if(r->balance == a)
{
p = r;
*link(a, s) = *link(-a, r);
*link(-a, s) = s;
s->balance = 0;
r->balance = 0;
//update value of RANk
if(a == 1)r->RANK = r->RANK + s->RANK;
if(a == -1) s->RANK = s->RANK - r->RANK;
}
else if (r->balance == -a)
{
p = *link(-a, p);
*link(a, r) = *link(a, p);
*link(a, p) = r;
*link(a, s) = *link(-a, p);
*link(-a, p) = s;
if (p->balance == a)
{
s->balance = -a;
r->balance = 0;
}
if (p->balance == 0)
{
s->balance = 0;
r->balance = 0;
}
if (p->balance == a)
{
s->balance = 0;
r->balance = -a;
}
p->balance = 0;
if(a == 1)
{
r->RANK = r->RANK - p->RANK;
p->RANK = p->RANK - s->RANK;
}
if(a == -1)
{
p->RANK = p->RANK + r->RANK;
s->RANK = s->RANK - p->RANK;
}
}
if(s == t->rlink)t->rlink = p;
else t->llink = p;
}
};
//哈夫曼二叉树:
//头文件:
template<class T>
class HuffmanNode
{
private:
HuffmanNode<T> *left;
HuffmanNode<T> *right;
T data;
int weight;
public:
HuffmanNode(const T &item, HuffmanNode<T> *lptr = NULL, HuffmanNode<T> *rptr = NULL):data(item),left(lptr),right(rptr),weight(0){}
HuffmanNode<T> *GetLeft(void) const {return left;}
void SetLeft(HuffmanNode<T> *L) {left = L;}
HuffmanNode<T> *Getright(void) const{return right;}
void SetRight(HuffmanNode<T> *R) {right = R;}
T &GetData() {return data;}
void SetData(const T &item) {data = item;}
int GetWeight() {return weight;}
void SetWeight(const int w){weight = w;}
};
const int m = 20;
template<class T>
class HuffmanTree
{
private:
HuffmanNode<T> *root;
T data[m];
int weight[m];
public:
HuffmanTree(HuffmanNode<T> *t = NULL):root(t){}
void CreateHuffmanTree();
HuffmanNode<T> *GetRoot() {return root;}
void SetRoot(HuffmanNode<T> *t) {root = t;}
void InputNodes();
};
//源文件:
#include "HuffmanTree.h"
template<class T>
void HuffmanTree<T>::CreateHuffmanTree()
{
InputNodes();
HuffmanNode<T> *H[m];
HuffmanNode<T> *p1 = NULL, *p2 = NULL, *p, *t;
int i = 0, j = 0;
for (; i < m ; i ++)
{
H[i] = new HuffmanNode<T>(0);
H[i]->SetData(data[i]);
H[i]->SetWeight(weight[i]);
H[i]->SetLeft(NULL);
H[i]->SetRight(NULL);
}
for (i = 0; i < m-1; i ++)
{
t = new HuffmanNode<T>(0);
p1 = H[i];
p2 = H[i+1];
t->SetWeight(p1->GetWeight() + p2->GetWeight());
t->SetLeft(p1);
t->SetRight(p2);
p = t;
j = i+2;
while(j < m && (p->GetWeight()) > (H[i]->GetWeight()))
{
H[i-1] = H[j];
j ++;
}
H[j-1] = p;
root = H[m-1];
}
}