湖南师范大学数据结构实验（三）

3、 二叉树的常见操作
背景知识：二叉树的存储、建立、遍历及其应用
目的要求

1. 掌握二叉树的存储实现。
2. 掌握二叉树的遍历思想。
3. 掌握二叉树的常见算法的程序实现。
   实验内容及步骤：
4. 输入字符序列，建立二叉链表。
5. 求先序、中序和后序遍历序列，并显示输出。
6. 求二叉树的深度，并显示输出 。
7. 求二叉树的结点总数，并显示输出。
   测试数据：输入字符序列ABCØØDEØGØØFØØØ

#include<cstdio>
#include<cstdlib>
#include<iostream>
using namespace std;

int read() {int x; cin >> x; return x;}

struct node
{
    char data;
    node *lson,*rson;
};

template<typename T> struct queue
{
    int ft = 0,rear = 0;
    T a[10010];
    void push(T x){
        if((ft+1)%10010 == rear) exit(-1);
        ft = (ft+1)%10010;
        a[ft] = x;
    }
    T& front() {
        if(rear == ft) exit(-1);
        return a[(rear+1)%10010];
    }
    void pop() {
        if(rear == ft) exit(-1);
        rear = (rear+1)%10010;
    }
};

node * newnode()
{
    node *p = (node *)malloc(sizeof(node));
    p -> data = 0;
    p -> lson = p -> rson = 0;
    return p;
}

char s[10000];
void build(node *&root)
{
    queue<node *> Q1;
    cin >> s;
    root = newnode();
    root -> data = s[0];
    Q1.push(root);
    for(int i = 1; s[i]; i++){
        node *&now  = Q1.front();
        Q1.pop();
        if(s[i] != '0')  {
            now -> lson = newnode();
            now -> lson -> data = s[i];
            Q1.push(now -> lson);
        }
        if(s[++i] != '0' && s[i]) {
            now -> rson = newnode();
            now -> rson -> data = s[i];
            Q1.push(now -> rson);
        }
    }
}

void dlr(node *now)
{
    if(!now) return;
    cout << now -> data << ' ';
    dlr(now -> lson);
    dlr(now -> rson);
}

void ldr(node *now)
{
    if(!now) return;
    ldr(now -> lson);
    cout << now -> data << ' ';
    ldr(now -> rson);
}

void lrd(node *now)
{
    if(!now) return;
    lrd(now -> lson);
    lrd(now -> rson);
    cout << now -> data << ' ';
}

int DEP,SIZE;

void doit(node *now,int dep)
{
    if(!now) return;
    if(dep > DEP) DEP = dep;
    SIZE++;
    doit(now -> lson,dep+1);
    doit(now -> rson,dep+1);
}

int main()
{
    node *root;
    build(root);
    void printTree(node *);
    printf("the tree is :\n\n");
    printTree(root);
    putchar('\n');
    printf("先序遍历:  ");dlr(root);
    printf("\n中序遍历:  ");ldr(root);
    printf("\n后序遍历:  ");lrd(root);
    doit(root,1);
    printf("\n深度:  %d",DEP);
    printf("\n结点大小:  %d\n",SIZE);
    return 0;
}

void getDeep(node *now,int dep,int &maxDep)
{
    if(!now) return;
    if(dep > maxDep) maxDep = dep;
    getDeep(now->lson,dep+1,maxDep);
    getDeep(now->rson,dep+1,maxDep);
}

int map[1000][1000];
int dep;

void paint(int row,int l,int r,int dp)
{
    if(dp > dep) return;
    if(dp == dep){
        if(l&1) map[row+1][l] = 1;
        if(r&1) map[row+1][r] = 1;
        return;
    }
    int col = l+r>>1;
    map[row][col] = 1;
    int deta = col-(l+col)/2;
    paint(row+deta,l,col-1,dp+1);
    paint(row+deta,col+1,r,dp+1);
}

void dfs1(int,int,node *);void dfs2(int,int,node *);
void printTree(node *root)
{
    getDeep(root,1,dep);
    int l = 1,r = 1<<dep-2;r *= 6;
    paint(1,l,r-1,1);
    map[1][l+r>>1] = root -> data;
    if(root -> lson)dfs1(2,(l+r>>1)-1,root->lson);
    if(root -> rson)dfs2(2,(l+r>>1)+1,root->rson);
    for(int i = 0; i < r; i++){
        for(int j = 0; j < r; j++){
            if(map[i][j] == 1) putchar(' ');
            if(map[i][j] > 3) putchar(map[i][j]);
            if(map[i][j] == 2) putchar('/');
            if(map[i][j] == 3) putchar('\\');
            if(map[i][j] == 0) putchar(' ');
        }
        putchar('\n');
        if(map[i][1]>0)break;
    }
}

void dfs1(int x,int y,node *p)
{
    if(map[x][y] == 1){
        map[x][y] = p -> data;
        if(p -> lson) dfs1(x+1,y-1,p->lson);
        if(p -> rson) dfs2(x+1,y+1,p->rson);
        return;
    }
    map[x][y] = 2;
    dfs1(x+1,y-1,p);
}

void dfs2(int x,int y,node *p)
{
    if(map[x][y] == 1){
        map[x][y] = p->data;
        if(p -> lson) dfs1(x+1,y-1,p->lson);
        if(p -> rson) dfs2(x+1,y+1,p->rson);
        return;
    }
    map[x][y] = 3;
    dfs2(x+1,y+1,p);
}

测试