读书笔记之：数据结构，算法与应用（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;

}