数据结构，算法与应用（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)表达式中,操作符位于操作数之前。在前缀和后缀表达式中不会存在歧义。因此,在前缀和后缀表达式中都不必采用括号或优先级。从左到右或从右到左扫描表达式并采用操作数栈,可以很容易确定操作数和操作符的关系。若在扫描中遇到一个操作数,把它压入堆栈,若遇到一个操作符,则将其与栈顶的操作数相匹配。把这些操作数推出栈,由操作符执行相应的计算,并将所得结果作为操作数压入堆栈。

7. 抽象数据结构：二叉树

二叉树节点代码：



#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

数据类型二叉树类：



#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

二叉树测试代码：



#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();

}

8. 删除二叉树

要删除一棵二叉树,需要删除其所有节点。可以通过后序遍历在访问一个节点时,把其删除。也就是说先删除左子树,然后右子树,最后删除根。

9. 计算高度

通过进行后序遍历,可以得到二叉树的高度。首先得到左子树的高度 hl,然后得到右子树的高度hr。此时,树的高度为:

max{hl,hr} + 1

10.设置信号放大器

代码如下：



#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();

}

11. 树与二叉树（详细介绍）

12. 在线等价类问题

（1）利用数组解决

代码如下：



//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;

}

（2）利用树解决

代码如下：



//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;

}

（3）利用重量或高度规则来提高性能
代码如下：



// 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;

}