读书笔记之:数据结构,算法与应用(3)
第8章 二叉树和其他树
1. 术语:
树和二叉树的术语,如高度、深度、层、根、叶子、子节点、父节点和兄弟节点。
4种常用的二叉树遍历方法:前序遍历,中序遍历,后序遍历和按层遍历。
2. 线性数据结构,表数据结构,层次数据结构
3. 二叉树与树的根本区别
4. 二叉树的特性
5. 二叉树遍历方法
在前三种方法中,每个节点的左子树在其右子树之前遍历。这三种遍历的区别在于对同一个节点在不同时刻进行访问。在进行前序遍历时,每个节点是在其左右子树被访问之前进行访问的;在中序遍历时,首先访问左子树,然后访问子树的根节点,最后访问右子树。在后序遍历时,当左右子树均访问完之后才访问子树的根节点。
在逐层遍历过程中,按从顶层到底层的次序访问树中元素,在同一层中,从左到右进行访问。由于遍历中所使用的数据结构是一个队列而不是栈,因此写一个按层遍历的递归程序很困难。
6. 二叉树遍历一个常用问题:数学表达式的形式
当对一棵数学表达式树进行中序,前序和后序遍历时,就分别得到表达式的中缀、前缀和后缀形式。中缀( infix)形式即平时所书写的数学表达式形式,在这种形式中,每个二元操作符(也就是有两个操作数的操作符)出现在左操作数之后,右操作数之前。在使用中缀形式时,可能会产生一些歧义。例如, x+y×z 可以理解为 (x+y)×z 或x+(y×z)。为了避免这种歧义,可
对操作符赋于优先级并采用优先级规则来分析中缀表达式。在完全括号化的中缀表达式中,每个操作符和相应的操作数都用一对括号括起来。更甚者把操作符的每个操作数也都用一对括号括起来。如 ((x)+(y)),((x)+((y)*(z)))和(((x)+(y))*((y)+(z)))*(w)。
在后缀(postfix)表达式中,每个操作符跟在操作数之后,操作数按从左到右的顺序出现。在前缀( p r e f i x)表达式中,操作符位于操作数之前。在前缀和后缀表达式中不会存在歧义。因此,在前缀和后缀表达式中都不必采用括号或优先级。从左到右或从右到左扫描表达式并采用操作数栈,可以很容易确定操作数和操作符的关系。若在扫描中遇到一个操作数,把它压入堆栈,若遇到一个操作符,则将其与栈顶的操作数相匹配。把这些操作数推出栈,由操作符执行相应的计算,并将所得结果作为操作数压入堆栈。
![](data:image/png;base64,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)
1. 术语:
树和二叉树的术语,如高度、深度、层、根、叶子、子节点、父节点和兄弟节点。
4种常用的二叉树遍历方法:前序遍历,中序遍历,后序遍历和按层遍历。
2. 线性数据结构,表数据结构,层次数据结构
3. 二叉树与树的根本区别
在前三种方法中,每个节点的左子树在其右子树之前遍历。这三种遍历的区别在于对同一个节点在不同时刻进行访问。在进行前序遍历时,每个节点是在其左右子树被访问之前进行访问的;在中序遍历时,首先访问左子树,然后访问子树的根节点,最后访问右子树。在后序遍历时,当左右子树均访问完之后才访问子树的根节点。
在逐层遍历过程中,按从顶层到底层的次序访问树中元素,在同一层中,从左到右进行访问。由于遍历中所使用的数据结构是一个队列而不是栈,因此写一个按层遍历的递归程序很困难。
当对一棵数学表达式树进行中序,前序和后序遍历时,就分别得到表达式的中缀、前缀和后缀形式。中缀( infix)形式即平时所书写的数学表达式形式,在这种形式中,每个二元操作符(也就是有两个操作数的操作符)出现在左操作数之后,右操作数之前。在使用中缀形式时,可能会产生一些歧义。例如, x+y×z 可以理解为 (x+y)×z 或x+(y×z)。为了避免这种歧义,可
对操作符赋于优先级并采用优先级规则来分析中缀表达式。在完全括号化的中缀表达式中,每个操作符和相应的操作数都用一对括号括起来。更甚者把操作符的每个操作数也都用一对括号括起来。如 ((x)+(y)),((x)+((y)*(z)))和(((x)+(y))*((y)+(z)))*(w)。
在后缀(postfix)表达式中,每个操作符跟在操作数之后,操作数按从左到右的顺序出现。在前缀( p r e f i x)表达式中,操作符位于操作数之前。在前缀和后缀表达式中不会存在歧义。因此,在前缀和后缀表达式中都不必采用括号或优先级。从左到右或从右到左扫描表达式并采用操作数栈,可以很容易确定操作数和操作符的关系。若在扫描中遇到一个操作数,把它压入堆栈,若遇到一个操作符,则将其与栈顶的操作数相匹配。把这些操作数推出栈,由操作符执行相应的计算,并将所得结果作为操作数压入堆栈。
7. 抽象数据结构:二叉树
View Code
View Code
View Code 8. 删除二叉树
要删除一棵二叉树,需要删除其所有节点。可以通过后序遍历在访问一个节点时,把其删除。也就是说先删除左子树,然后右子树,最后删除根。
9. 计算高度
通过进行后序遍历,可以得到二叉树的高度。首先得到左子树的高度 hl,然后得到右子树的高度hr。此时,树的高度为:
max{hl,hr} + 1
二叉树节点代码:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#ifndef _BINARYTREENODE_H_
#define _BINARYTREENODE_H_
template <class T>
class BinaryTree;
class Booster;
template <class T>
class BinaryTreeNode{
friend class BinaryTree<T>;
friend class Booster;
friend void PlaceBoosters(BinaryTreeNode<Booster>*);
public:
BinaryTreeNode(){
lchild=rchild=0;
}
BinaryTreeNode(const T& e){
data=e;
lchild=rchild=0;
}
BinaryTreeNode(const T& e,BinaryTreeNode<T>* l,BinaryTreeNode<T>* r){
data=e;
lchild=l;
rchild=r;
}
T getData(){
return data;
}
BinaryTreeNode<T>* getLChild(){
return lchild;
}
BinaryTreeNode<T>* getRChild(){
return rchild;
}
void setData(const T& e){
data=e;
}
void setLChild(BinaryTreeNode<T>* l){
lchild=l;
}
void setRChild(BinaryTreeNode<T>* r){
rchild=r;
}
private:
T data;
BinaryTreeNode<T> *lchild;
BinaryTreeNode<T> *rchild;
};
#endif
#define _BINARYTREENODE_H_
template <class T>
class BinaryTree;
class Booster;
template <class T>
class BinaryTreeNode{
friend class BinaryTree<T>;
friend class Booster;
friend void PlaceBoosters(BinaryTreeNode<Booster>*);
public:
BinaryTreeNode(){
lchild=rchild=0;
}
BinaryTreeNode(const T& e){
data=e;
lchild=rchild=0;
}
BinaryTreeNode(const T& e,BinaryTreeNode<T>* l,BinaryTreeNode<T>* r){
data=e;
lchild=l;
rchild=r;
}
T getData(){
return data;
}
BinaryTreeNode<T>* getLChild(){
return lchild;
}
BinaryTreeNode<T>* getRChild(){
return rchild;
}
void setData(const T& e){
data=e;
}
void setLChild(BinaryTreeNode<T>* l){
lchild=l;
}
void setRChild(BinaryTreeNode<T>* r){
rchild=r;
}
private:
T data;
BinaryTreeNode<T> *lchild;
BinaryTreeNode<T> *rchild;
};
#endif
数据类型二叉树类:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#ifndef _BINARYTREE_H_
#define _BINARYTREE_H_
#include <iostream>
#include <queue>
#include "BinaryTreeNode.h"
int _count;
template <class T>
class BinaryTree{
public:
BinaryTree():root(0){}
~BinaryTree(){}
bool IsEmpty()const{
return root?false:true;
}
bool Root(T& x)const;
void MakeTree(const T& elem,BinaryTree<T>& left,BinaryTree<T>& right);
void BreakTree(T& elem,BinaryTree<T>& left,BinaryTree<T>& right);
void PreOrder(void(*Visit)(BinaryTreeNode<T>* u)){
PreOrder(Visit,root);
}
void InOrder(void(*Visit)(BinaryTreeNode<T>* u)){
InOrder(Visit,root);
}
void PostOrder(void(*Visit)(BinaryTreeNode<T>* u)){
PostOrder(Visit,root);
}
void LevelOrder(void(*Visit)(BinaryTreeNode<T>*u));
void PreOutput(){
PreOrder(Output,root);
std::cout<<std::endl;
}
void InOutput(){
InOrder(Output,root);
std::cout<<std::endl;
}
void PostOutput(){
PostOrder(Output,root);
std::cout<<std::endl;
}
void LevelOutput(){
LevelOrder(Output);
std::cout<<std::endl;
}
void Delete(){
PostOrder(Free,root);
root=0;
}
int Height()const{
return Height(root);
}
int Size(){
_count=0;
PreOrder(Add1,root);
return _count;
}
private:
BinaryTreeNode<T> *root;
void PreOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>* t);
void InOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>* t);
void PostOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>* t);
static void Output(BinaryTreeNode<T>* t){
std::cout<<t->data<<' ';
}
static void Free(BinaryTreeNode<T>* t){
delete t;
}
int Height(BinaryTreeNode<T> *t)const;
static void Add1(BinaryTreeNode<T>* t){
_count++;
}
};
template <class T>
bool BinaryTree<T>::Root(T& x)const
{
if(root){
x=root->data;
return true;
}
else
return false;
}
template <class T>
void BinaryTree<T>::MakeTree(const T& elem,BinaryTree<T>& left,BinaryTree<T>& right)
{
root=new BinaryTreeNode<T>(elem,left.root,right.root);
left.root=right.root=0;
}
template <class T>
void BinaryTree<T>::BreakTree(T& elem,BinaryTree<T>& left,BinaryTree<T>& right)
{
if(!root)
throw "BadInput";
elem=root->data;
left.root=root->lchild;
right.root=root->rchild;
delete root;
root=0;
}
template <class T>
void BinaryTree<T>::PreOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>* t)
{
if(t){
Visit(t);
PreOrder(Visit,t->lchild);
PreOrder(Visit,t->rchild);
}
}
template <class T>
void BinaryTree<T>::InOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>* t)
{
if(t){
InOrder(Visit,t->lchild);
Visit(t);
InOrder(Visit,t->rchild);
}
}
template <class T>
void BinaryTree<T>::PostOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>* t)
{
if(t){
PostOrder(Visit,t->lchild);
PostOrder(Visit,t->rchild);
Visit(t);
}
}
template <class T>
void BinaryTree<T>::LevelOrder(void(*Visit)(BinaryTreeNode<T>*u )){
std::queue<BinaryTreeNode<T>*> qu;
BinaryTreeNode<T>* t;
qu.push(root);
while(!qu.empty()){
t=qu.front();
if(t){
Visit(t);
if(t->lchild)
qu.push(t->lchild);
if(t->rchild)
qu.push(t->rchild);
}
qu.pop();
}
}
template <class T>
int BinaryTree<T>::Height(BinaryTreeNode<T> *t)const{
if(!t)
return 0;
int hl=Height(t->lchild);
int hr=Height(t->rchild);
if(hl>hr)
return ++hl;
else
return ++hr;
}
#endif
#define _BINARYTREE_H_
#include <iostream>
#include <queue>
#include "BinaryTreeNode.h"
int _count;
template <class T>
class BinaryTree{
public:
BinaryTree():root(0){}
~BinaryTree(){}
bool IsEmpty()const{
return root?false:true;
}
bool Root(T& x)const;
void MakeTree(const T& elem,BinaryTree<T>& left,BinaryTree<T>& right);
void BreakTree(T& elem,BinaryTree<T>& left,BinaryTree<T>& right);
void PreOrder(void(*Visit)(BinaryTreeNode<T>* u)){
PreOrder(Visit,root);
}
void InOrder(void(*Visit)(BinaryTreeNode<T>* u)){
InOrder(Visit,root);
}
void PostOrder(void(*Visit)(BinaryTreeNode<T>* u)){
PostOrder(Visit,root);
}
void LevelOrder(void(*Visit)(BinaryTreeNode<T>*u));
void PreOutput(){
PreOrder(Output,root);
std::cout<<std::endl;
}
void InOutput(){
InOrder(Output,root);
std::cout<<std::endl;
}
void PostOutput(){
PostOrder(Output,root);
std::cout<<std::endl;
}
void LevelOutput(){
LevelOrder(Output);
std::cout<<std::endl;
}
void Delete(){
PostOrder(Free,root);
root=0;
}
int Height()const{
return Height(root);
}
int Size(){
_count=0;
PreOrder(Add1,root);
return _count;
}
private:
BinaryTreeNode<T> *root;
void PreOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>* t);
void InOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>* t);
void PostOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>* t);
static void Output(BinaryTreeNode<T>* t){
std::cout<<t->data<<' ';
}
static void Free(BinaryTreeNode<T>* t){
delete t;
}
int Height(BinaryTreeNode<T> *t)const;
static void Add1(BinaryTreeNode<T>* t){
_count++;
}
};
template <class T>
bool BinaryTree<T>::Root(T& x)const
{
if(root){
x=root->data;
return true;
}
else
return false;
}
template <class T>
void BinaryTree<T>::MakeTree(const T& elem,BinaryTree<T>& left,BinaryTree<T>& right)
{
root=new BinaryTreeNode<T>(elem,left.root,right.root);
left.root=right.root=0;
}
template <class T>
void BinaryTree<T>::BreakTree(T& elem,BinaryTree<T>& left,BinaryTree<T>& right)
{
if(!root)
throw "BadInput";
elem=root->data;
left.root=root->lchild;
right.root=root->rchild;
delete root;
root=0;
}
template <class T>
void BinaryTree<T>::PreOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>* t)
{
if(t){
Visit(t);
PreOrder(Visit,t->lchild);
PreOrder(Visit,t->rchild);
}
}
template <class T>
void BinaryTree<T>::InOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>* t)
{
if(t){
InOrder(Visit,t->lchild);
Visit(t);
InOrder(Visit,t->rchild);
}
}
template <class T>
void BinaryTree<T>::PostOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>* t)
{
if(t){
PostOrder(Visit,t->lchild);
PostOrder(Visit,t->rchild);
Visit(t);
}
}
template <class T>
void BinaryTree<T>::LevelOrder(void(*Visit)(BinaryTreeNode<T>*u )){
std::queue<BinaryTreeNode<T>*> qu;
BinaryTreeNode<T>* t;
qu.push(root);
while(!qu.empty()){
t=qu.front();
if(t){
Visit(t);
if(t->lchild)
qu.push(t->lchild);
if(t->rchild)
qu.push(t->rchild);
}
qu.pop();
}
}
template <class T>
int BinaryTree<T>::Height(BinaryTreeNode<T> *t)const{
if(!t)
return 0;
int hl=Height(t->lchild);
int hr=Height(t->rchild);
if(hl>hr)
return ++hl;
else
return ++hr;
}
#endif
二叉树测试代码:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#include <iostream>
#include "BinaryTree.h"
using namespace std;
int count=0;
BinaryTree<int> a,x,y,z;
template<class T>
void ct(BinaryTreeNode<T> *t){
count++;
}
void test1(){
y.MakeTree(10,a,a);
z.MakeTree(20,a,a);
x.MakeTree(30,y,z);
y.MakeTree(40,x,a);
y.PreOrder(ct);
cout<<count<<endl;
y.PreOutput();
y.InOutput();
y.PostOutput();
y.LevelOutput();
}
void test2(){
y.MakeTree(1,a,a);
z.MakeTree(2,a,a);
x.MakeTree(3,y,z);
y.MakeTree(4,x,a);
cout << "Preorder sequence is ";
y.PreOutput();
cout << "Inorder sequence is ";
y.InOutput();
cout << "Postorder sequence is ";
y.PostOutput();
cout << "Level order sequence is ";
y.LevelOutput();
cout << "Number of nodes = ";
cout << y.Size() << endl;
cout << "Height = ";
cout << y.Height() << endl;
y.PreOrder(ct);
cout << "Count of nodes is " << count << endl;
}
int main(){
test2();
}
#include "BinaryTree.h"
using namespace std;
int count=0;
BinaryTree<int> a,x,y,z;
template<class T>
void ct(BinaryTreeNode<T> *t){
count++;
}
void test1(){
y.MakeTree(10,a,a);
z.MakeTree(20,a,a);
x.MakeTree(30,y,z);
y.MakeTree(40,x,a);
y.PreOrder(ct);
cout<<count<<endl;
y.PreOutput();
y.InOutput();
y.PostOutput();
y.LevelOutput();
}
void test2(){
y.MakeTree(1,a,a);
z.MakeTree(2,a,a);
x.MakeTree(3,y,z);
y.MakeTree(4,x,a);
cout << "Preorder sequence is ";
y.PreOutput();
cout << "Inorder sequence is ";
y.InOutput();
cout << "Postorder sequence is ";
y.PostOutput();
cout << "Level order sequence is ";
y.LevelOutput();
cout << "Number of nodes = ";
cout << y.Size() << endl;
cout << "Height = ";
cout << y.Height() << endl;
y.PreOrder(ct);
cout << "Count of nodes is " << count << endl;
}
int main(){
test2();
}
要删除一棵二叉树,需要删除其所有节点。可以通过后序遍历在访问一个节点时,把其删除。也就是说先删除左子树,然后右子树,最后删除根。
9. 计算高度
通过进行后序遍历,可以得到二叉树的高度。首先得到左子树的高度 hl,然后得到右子树的高度hr。此时,树的高度为:
max{hl,hr} + 1
10.设置信号放大器
代码如下:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#include <iostream>
#include "BinaryTree.h"
using namespace std;
int tolerance = 3;
class Booster{
friend int main();
friend void PlaceBoosters(BinaryTreeNode<Booster>*);
public:
void Output(ostream& out)const{
out<<boost<<' '<<D<<' '<<d<<' ';
}
private:
int D,d;
bool boost;
};
ostream& operator<<(ostream& out,const Booster& x)
{
x.Output(out);
return out;
}
void PlaceBoosters(BinaryTreeNode<Booster>* x){
BinaryTreeNode<Booster> *y=x->getLChild();
int degr;
Booster btr;
btr.D=0;
x->data.D=0;
if(y){
degr=(y->getData()).D+(y->getData()).d;
if(degr>tolerance){
y->data.boost=true;
x->data.D=y->data.d;
}
else
x->data.D=degr;
}
y=x->getRChild();
if(y){
degr=y->data.D+y->data.d;
if(degr>tolerance) {
y->data.boost=true;
degr=y->data.d;
}
if(x->data.D<degr)
x->data.D=degr;
}
}
BinaryTree<Booster> T, U, V, W, X, Y;
int main(void)
{
Booster a, b;
a.d = 2; a.D =0; a.boost = 0;
b.d=1; b.D=0; b.boost = 0;
U.MakeTree(a,X,X);
V.MakeTree(b,U,X);
U.MakeTree(a,X,X);
W.MakeTree(a,U,X);
b.d=3;
U.MakeTree(b,V,W);
V.MakeTree(a,X,X);
b.d=3;
W.MakeTree(b,X,X);
Y.MakeTree(a,V,W);
W.MakeTree(a,X,X);
T.MakeTree(b,Y,W);
b.d=0;
V.MakeTree(b,T,U);
V.PostOrder(PlaceBoosters);
V.PostOutput();
}
#include "BinaryTree.h"
using namespace std;
int tolerance = 3;
class Booster{
friend int main();
friend void PlaceBoosters(BinaryTreeNode<Booster>*);
public:
void Output(ostream& out)const{
out<<boost<<' '<<D<<' '<<d<<' ';
}
private:
int D,d;
bool boost;
};
ostream& operator<<(ostream& out,const Booster& x)
{
x.Output(out);
return out;
}
void PlaceBoosters(BinaryTreeNode<Booster>* x){
BinaryTreeNode<Booster> *y=x->getLChild();
int degr;
Booster btr;
btr.D=0;
x->data.D=0;
if(y){
degr=(y->getData()).D+(y->getData()).d;
if(degr>tolerance){
y->data.boost=true;
x->data.D=y->data.d;
}
else
x->data.D=degr;
}
y=x->getRChild();
if(y){
degr=y->data.D+y->data.d;
if(degr>tolerance) {
y->data.boost=true;
degr=y->data.d;
}
if(x->data.D<degr)
x->data.D=degr;
}
}
BinaryTree<Booster> T, U, V, W, X, Y;
int main(void)
{
Booster a, b;
a.d = 2; a.D =0; a.boost = 0;
b.d=1; b.D=0; b.boost = 0;
U.MakeTree(a,X,X);
V.MakeTree(b,U,X);
U.MakeTree(a,X,X);
W.MakeTree(a,U,X);
b.d=3;
U.MakeTree(b,V,W);
V.MakeTree(a,X,X);
b.d=3;
W.MakeTree(b,X,X);
Y.MakeTree(a,V,W);
W.MakeTree(a,X,X);
T.MakeTree(b,Y,W);
b.d=0;
V.MakeTree(b,T,U);
V.PostOrder(PlaceBoosters);
V.PostOutput();
}
11. 树与二叉树(详细介绍)
12. 在线等价类问题
(1)利用数组解决
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
//Online equivalence class functions using arrays
#include <iostream>
using namespace std;
int *E, n;
void Initialize(int n)
{// Initialize n classes with one element each.
E = new int [n + 1];
for (int e = 1; e <= n; e++)
E[e] = e;
}
void Union(int i, int j)
{// Union the classes i and j.
for (int k = 1; k <= n; k++)
if (E[k] == j) E[k] = i;
}
int Find(int e)
{// Find the class that contains element i.
return E[e];
}
int main(void)
{
n = 10;
Initialize(n);
Union(1,2);
Union(3,4);
Union(1,3);
cout << '1' << ' ' << Find(1) << ' ' << '2' << ' ' << Find(2) << endl;
cout << '3' << ' ' << Find(3) << ' ' << '4' << ' ' << Find(4) << endl;
cout << '5' << ' ' << Find(5) << ' ' << '6' << ' ' << Find(6) << endl;
}
#include <iostream>
using namespace std;
int *E, n;
void Initialize(int n)
{// Initialize n classes with one element each.
E = new int [n + 1];
for (int e = 1; e <= n; e++)
E[e] = e;
}
void Union(int i, int j)
{// Union the classes i and j.
for (int k = 1; k <= n; k++)
if (E[k] == j) E[k] = i;
}
int Find(int e)
{// Find the class that contains element i.
return E[e];
}
int main(void)
{
n = 10;
Initialize(n);
Union(1,2);
Union(3,4);
Union(1,3);
cout << '1' << ' ' << Find(1) << ' ' << '2' << ' ' << Find(2) << endl;
cout << '3' << ' ' << Find(3) << ' ' << '4' << ' ' << Find(4) << endl;
cout << '5' << ' ' << Find(5) << ' ' << '6' << ' ' << Find(6) << endl;
}
(2)利用树解决
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
//Simple tree solution to union-find problem
//
#include <iostream>
using namespace std;
int *parent;
void Initialize(int n){
parent=new int[n+1];
for(int e=1;e<=n;e++)
parent[e]=0;
}
int Find(int e){
while(parent[e])
e=parent[e];
return e;
}
void Union(int i,int j){
parent[j]=i;
}
int main(void)
{
Initialize(10);
Union(1,2);
Union(3,4);
Union(1,3);
cout << "Find(1) = " << Find(1) << " Find(2) = " << Find(2) << endl;
cout << "Find(3) = " << Find(3) << " Find(4) = " << Find(4) << endl;
cout << "Find(5) = " << Find(5) << " Find(6) = " << Find(6) << endl;
}
//
#include <iostream>
using namespace std;
int *parent;
void Initialize(int n){
parent=new int[n+1];
for(int e=1;e<=n;e++)
parent[e]=0;
}
int Find(int e){
while(parent[e])
e=parent[e];
return e;
}
void Union(int i,int j){
parent[j]=i;
}
int main(void)
{
Initialize(10);
Union(1,2);
Union(3,4);
Union(1,3);
cout << "Find(1) = " << Find(1) << " Find(2) = " << Find(2) << endl;
cout << "Find(3) = " << Find(3) << " Find(4) = " << Find(4) << endl;
cout << "Find(5) = " << Find(5) << " Find(6) = " << Find(6) << endl;
}
(3)利用重量或高度规则来提高性能
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
// union/find with weighting rule
#include <iostream>
#include <cstdlib>
using namespace std;
int *parent;
bool *root;
void Initialize(int n)
{// One element per set/class/tree.
root = new bool[n+1];
parent = new int[n+1];
for (int e = 1; e <= n; e++) {
parent[e] = 1;
root[e] = true;}
}
int Find(int e)
{// Return root of tree containing e.
while (!root[e])
e = parent[e]; // move up one level
return e;
}
int Find_compact(int e)
{// Return root of tree containing e.
// Compact path from e to root.
int j = e;
// find root
while (!root[j])
j = parent[j];
// compact
int f = e; // start at e
while (f != j) {// f is not root
int pf = parent[f];
parent[f] = j; // move f to level 2
f = pf; // f moves to old parent
}
return j;
}
void Union(int i, int j)
{// Combine trees with roots i and j.
// Use weighting rule.
if (parent[i] < parent[j]) {
// i becomes subtree of j
parent[j] += parent[i];
root[i] = false;
parent[i] = j; }
else {// j becomes subtree of i
parent[i] += parent[j];
root[j] = false;
parent[j] = i;}
}
int main(void)
{
Initialize(10);
Union(1,2);
Union(3,4);
Union(1,3);
cout << '1' << ' ' << Find(1) << ' ' << '2' << ' ' << Find(2) << endl;
cout << '3' << ' ' << Find(3) << ' ' << '4' << ' ' << Find(4) << endl;
cout << '5' << ' ' << Find(5) << ' ' << '6' << ' ' << Find(6) << endl;
}
#include <iostream>
#include <cstdlib>
using namespace std;
int *parent;
bool *root;
void Initialize(int n)
{// One element per set/class/tree.
root = new bool[n+1];
parent = new int[n+1];
for (int e = 1; e <= n; e++) {
parent[e] = 1;
root[e] = true;}
}
int Find(int e)
{// Return root of tree containing e.
while (!root[e])
e = parent[e]; // move up one level
return e;
}
int Find_compact(int e)
{// Return root of tree containing e.
// Compact path from e to root.
int j = e;
// find root
while (!root[j])
j = parent[j];
// compact
int f = e; // start at e
while (f != j) {// f is not root
int pf = parent[f];
parent[f] = j; // move f to level 2
f = pf; // f moves to old parent
}
return j;
}
void Union(int i, int j)
{// Combine trees with roots i and j.
// Use weighting rule.
if (parent[i] < parent[j]) {
// i becomes subtree of j
parent[j] += parent[i];
root[i] = false;
parent[i] = j; }
else {// j becomes subtree of i
parent[i] += parent[j];
root[j] = false;
parent[j] = i;}
}
int main(void)
{
Initialize(10);
Union(1,2);
Union(3,4);
Union(1,3);
cout << '1' << ' ' << Find(1) << ' ' << '2' << ' ' << Find(2) << endl;
cout << '3' << ' ' << Find(3) << ' ' << '4' << ' ' << Find(4) << endl;
cout << '5' << ' ' << Find(5) << ' ' << '6' << ' ' << Find(6) << endl;
}