POJ 2418 各种二叉排序树

　　题意很明确，统计各个字符串所占总串数的百分比，暴力的话肯定超时，看了书上的题解后发现这题主要是用二叉排序树来做，下面附上n种树的代码。

　　简单的二叉排序树，不作任何优化（C语言版的）：

#include<stdio.h>
#include<string.h>
#include<stdlib.h> 

typedef struct node{
    char name[52];
    struct node *lchild, *rchild;
    int count;
}node;

node *root= NULL;
int n = 0;

void insert(node **root, char *s){        //恶心的二级指针，以后还是用指针引用来替代吧 
    if(*root==NULL)    {
        node *p = (node*)malloc(sizeof(node));
        strcpy(p->name,s);
        p->lchild = p->rchild = NULL;
        p->count = 1;
        *root = p;        //切记这个不能漏了！！ 
    }
    else {
        int cmp= strcmp(s,((*root)->name));
        if(cmp==0)    ((*root)->count)++;
        else if(cmp<0)    insert(&((*root)->lchild),s);
        else    insert(&((*root)->rchild),s);
    }
}

void midOrder(node *root){
    if(root!=NULL){
        midOrder(root->lchild);
        printf("%s %.4f
",root->name,((double)(root->count)/(double)n)*100);
        midOrder(root->rchild);
    }
}

int main(){
    char s[52];
    while(gets(s)){
        insert(&root,s);
        ++n;
    }
    midOrder(root);
    return 0;
}

　　然后这是AVL（平衡二叉树），目前我只会插入的平衡，删除还不会，代码量还挺多的：

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
using namespace std;

struct AVL
{
    char name[32];
    int count;
    AVL *left, *right;
    int height;
};

int n = 0;

int Height(AVL *p)  {   return p== NULL? -1: p->height;  }

AVL* LLRotate(AVL *p)
{
    AVL *p2= p->left;
    p->left= p2->right;
    p2->right= p;
    p->height= max(Height(p->left), Height(p->right))+1;
    p2->height= max(Height(p->left), p->height)+1;
    return p2;
}

AVL* RRRotate(AVL *p)
{
    AVL *p2= p->right;
    p->right= p2->left;
    p2->left= p;
    p->height= max(Height(p->left), Height(p->right))+1;
    p2->height= max(p->height, Height(p2->right))+1;
    return p2;
}

AVL* LRRotate(AVL *p)
{
    p->left= RRRotate(p->left);
    return LLRotate(p);
}

AVL* RLRotate(AVL *p)
{
    p->right= LLRotate(p->right);
    return RRRotate(p);
}

AVL* Insert(const char *s, AVL *p)
{
    if(p==NULL){
        p= (AVL*)malloc(sizeof(AVL));
        strcpy(p->name, s);
        p->left= p->right= NULL;
        p->height= 0;
        p->count= 1;
    }
    else {
        int cmp= strcmp(s,p->name);
        if(cmp==0)  ++(p->count);
        else if(cmp<0){
            p->left= Insert(s,p->left);
            if(Height(p->left) - Height(p->right) == 2){
                if(strcmp(s,p->left->name)<0)
                    p= LLRotate(p);
                else    p= LRRotate(p);
            }
        }
        else if(cmp>0){
            p->right= Insert(s,p->right);
            if(Height(p->right) - Height(p->left) == 2){
                if(strcmp(s,p->right->name)>0)
                    p= RRRotate(p);
                else    p= RLRotate(p);
            }
        }
    }
    p->height= max(Height(p->left), Height(p->right))+1;
    return p;
}

void midOrder(AVL* p)
{
    if(p){
        midOrder(p->left);
        printf("%s %.4f
",p->name,double(p->count)/n*100);
        midOrder(p->right);
    }
}

int main()
{
    AVL *root= NULL;
    char s[32];
    while(gets(s)){
        root= Insert(s,root);
        ++n;
    }
    midOrder(root);
    return 0;
}

　　以上两者都参考了书上的代码模板，想简单一点的话可以直接用STL中封装的很好的 map（红黑树）：

#include<cstdio>
#include<map>
#include<iterator>
#include<string>
#include<iostream>
using namespace std;

int main()
{
    int n =0;
    string s;
    map<string,int> tree;
    while(getline(cin,s)){        //直接用cin的话空格会读不进去
        ++tree[s];
        ++n;
    }
    map<string,int>::iterator it;
    for(it=tree.begin(); it!=tree.end(); ++it){
    //    cout<<it->first;
        printf("%s %.4f
",it->first.c_str(), it->second*100.0/n);
    }
}

　　Treap树堆，通过随机确定的优先级来平衡二叉排序树，参考了刘汝佳大白书上的模板，旋转处的小技巧确实很巧妙：（如果单纯针对本题的话 remove 和 find 函数都可以不要，代码比AVL短一些）

#include<cstdio>
#include<cstdlib>
#include<ctime>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn= 32;

struct node
{
    node *ch[2];    //左右子树
    int r;      //优先级
    int s;      //结点总数
    char name[maxn];    //结点名称
    int num;        //结点出现次数
    node(char s2[])
    {
        strcpy(name,s2);
        num= 1;
        ch[0]= ch[1]= NULL;
        r= rand();
        s= 1;
    }
    bool operator <(const node &n2) const {  return r < n2.r;  }
    int cmp(char s2[]) const
    {
        int d= strcmp(name,s2);
        if(!d)  return -1;
        return  d<0? 0:1;
    }
    void maintain()
    {
        s= 1;
        if(ch[0]!=NULL)  s+= ch[0]->s;
        if(ch[1]!=NULL)  s+= ch[1]->s;
    }
};

node *treap= NULL;
int n= 0;

void rotate(node* &p, int d)
{
    node* k= p->ch[d^1];
    p->ch[d^1]= k->ch[d];
    k->ch[d]= p;
    p->maintain();
    k->maintain();
    p= k;
}

void insert(node* &p, char s2[])
{
    if(p==NULL)  p= new node(s2);
    else {
        int d= strcmp(s2,p->name);
        if(!d)  p->num++;
        else {
            d= d<0? 0:1;
            insert(p->ch[d],s2);
            if(p->ch[d]->r > p->r)  rotate(p,d^1);
        }
    }
    p->maintain();
}

void remove(node* &p, char s2[])
{
    if(p==NULL){
        puts("该结点不存在，无法删除...");
        return ;
    }
    int d= p->cmp(s2);
    if(d==-1){
        node *u= p;
        if(p->ch[0]==NULL)  p= p->ch[1];
        else if(p->ch[1]==NULL)  p= p->ch[0];
        else {
            int d2= (p->ch[0]->r > p->ch[1]->r ? 1: 0);
            rotate(p,d2);
            remove(p->ch[d2],s2);
        }
        delete u;
    }
    else    remove(p->ch[d],s2);
    if(p!=NULL)   p->maintain();
}

bool find(node* p, char s2[])
{
    while(p){
        int d= p->cmp(s2);
        if(d==-1)   return 1;
        else   p= p->ch[d];
    }
    return 0;
}

void midOrder(node *p)
{
    if(p){
        midOrder(p->ch[0]);
        printf("%s %.4f
",p->name,double(p->num)/n*100);
        midOrder(p->ch[1]);
    }
}

int main()
{
    char s[32];
    srand(time(NULL));
    while(gets(s)){
        insert(treap,s);
        ++n;
    }
    midOrder(treap);
    return 0;
}

　　实质上，这题也可以不用树来做，读入所有字符串并排序后，通过 lower_bound 和 upper_bound 函数的差值来依次求出每个字串的数量/百分比（这是从《挑战》书上学到的）：

#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<iostream>
#include<cstdlib>
using namespace std;
string str[1000006];

//这种方法可能相对会慢一点：2610ms，27640K，其余几种都是1000+ms

int main()
{
    int i= 0;
    while(getline(cin,str[i++])) ;
    sort(str,str+i);

    //因为最后的换行符也会读进去，所以ed要从1开始，而总数量是i-1而不是i
    int st,ed= 1;
    while(ed<i){
        st= lower_bound(str+ed, str+i, str[ed]) - str;
        ed= upper_bound(str+ed, str+i, str[ed]) - str;
        printf("%s %.4f
",str[st].c_str(), double(ed-st)/(i-1)*100);
    }
    return 0;
}

　　这两天稍微看了看数据结构，感觉还是挺费脑子的，各种变式的二叉排序树，很容易混淆或者记不住，看来要加深理解才能熟练运用。