tree

树的一些知识点

Expression trees, B and B* trees, red-black trees, quad trees, PQ trees

uva,536

为一棵n叉树，k为深度

考虑到所以猫的高度:  Ih(1+n/(n+1)+n*n/(n+1)*(n+1)+.....+n^k/(n+1)^k)

不工作的猫:1+n+n^2+....+n^k-Lc

得到。Lc=n^k    Ih=(n+1)^k

求n  log(Ih)/log(n+1)=log(Lc)/log(n);

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#define eps 1e-10
using namespace std;

int main()
{
    int Ih,Lc;
    int left,right;
    while(~scanf("%d %d",&Ih,&Lc))
    {
        if(!Ih && !Lc)
            break;
        int n,k=0;
        if(Lc==1)  //考虑情况为1，因为对等比数列来说，公比不能为一
//否则求前n项和就rte，
        {
            left=(ceil)(log(Ih)/log(2));  //int取整+0.5或者ceil
            right=2*Ih-1;
        }
        else
        {
        for(n=1;n<=Lc;n++)
        {
            if(fabs(log(n)*log(Ih)-log(Lc)*log(n+1))<eps)
                break;
        }
        k=(int)(log(Ih)/log(n+1)+0.5);
        left=(1-Lc)/(1-n);  
        right=(n+1)*Ih-n*Lc;
        }
        printf("%d %d
",left,right);
    }
    return 0;
}

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#define eps 1e-10
using namespace std;

int main()
{
    int Ih,Lc;
    int left,right;
    while(~scanf("%d %d",&Ih,&Lc))
    {
        if(!Ih && !Lc)
            break;
        int n=1,k=0;
        if(Lc==1)
        {
            left=(ceil)(log(Ih)/log(2));
            right=2*Ih-1;
        }
        else
        {
        while(fabs(log(n)*log(Ih)-log(Lc)*log(n+1))>eps)
            n++;
        k=(int)(log(Ih)/log(n+1)+0.5);
        left=(1-Lc)/(1-n);
        right=(n+1)*Ih-n*Lc;
        }
        printf("%d %d
",left,right);
    }
    return 0;
}

uva,536

前跟：先访问根再访问左再访问右子树

中跟：先访问左再访问根在访问右子树

后跟：先访问左子树再访问右子树再访问根

通过前根的点在中根中位置确定左右子树，然后递归最右再最左，压栈，压栈的顺序和后根遍历的顺序正好相反。

例如：DBACEGF  ABCDEFG

先对D找到在中根的位置，然后访问右边，然后找到E然后G然后F然后B,C,A，

#include <iostream>
#include <cstdio>
#include <cstring>
#include <stack>

using namespace std;

stack<char> st;
char PD[30],ID[30];

void find(int p1,int p2,int q1,int q2)
{
    if(p1>p2) return;
    st.push(PD[p1]);
    int root=q1;
    for(;ID[root]!=PD[p1];++root);
    find(root+1-q1+p1,p2,root+1,q2);
    find(p1+1,root-q1+p1,q1,root-1);
}

int main()
{
    while(cin>>PD>>ID)
    {
        int L=strlen(PD)-1;
        find(0,L,0,L);
        while(!st.empty())
        {
            char c=st.top();
            st.pop();
            printf("%c",c);
        }
        printf("
");
    }
    return 0;
}

通过先根和中根建树然后根据后根去遍历输出 （重写）

#include <iostream>
#include <cstring>
#include <cstdio>

using namespace std;

char PD[30],ID[30];

struct Node
{
    Node *left;
    Node *right;
    char c;
    Node(char c)
    {
        this->c=c;
        this->left=left;
        this->right=right;
    }
};

Node *root;

Node *Create_Tree(char *pre,char *min,int len)
{
    if(!len)
        return NULL;
    int p=0;
    while(min[p]!=pre[0])
        p++;
    Node *root=new Node(pre[0]);
    root->left=Create_Tree(pre+1,min,p);
    root->right=Create_Tree(pre+p+1,min+p+1,len-p-1);
    return root;
}

void print_Post(Node *r)
{
    if(r!=NULL)
    {
        print_Post(r->left);
        print_Post(r->right);
        printf("%c",r->c);
    }
}

int main()
{
    while(cin>>PD>>ID)
    {
        int L=strlen(PD);
        root=Create_Tree(PD,ID,L);
        print_Post(root);
        puts("");
    }
    return 0;
}

直接dfs递归求解，自己抽象出栈。

#include <iostream>
#include <cstring>

using namespace std;
char PD[30],ID[30];

void dfs(int p1,int p2,int q1,int q2,int root)
{
    if(p1>p2)
        return;
    for(root=q1;ID[root]!=PD[p1];++root);
    dfs(p1+1,root-q1+p1,q1,root-1,0);
    dfs(root+1-q1+p1,p2,root+1,q2,0);
    cout<<ID[root];
}

int main()
{
    while(cin>>PD>>ID)
    {
        int L=strlen(PD)-1;
        dfs(0,L,0,L,0);
        cout<<endl;
    }
    return 0;
}

 uva,122

#include <iostream>
#include <string>
#include <sstream>
#include <list>

using namespace std;
//建树
struct NODE
{
    int nVal;
    NODE *pL;
    NODE *pR;
}
//初始化空节点
const NullNode={0,0,0};
//删除树，避免泄漏内存
void DeleteTree(NODE *pPar)
{
    if(pPar!=NULL)
    {
        DeleteTree(pPar->pL);
        DeleteTree(pPar->pR);
    }
    delete pPar;
}
//生成二叉树
NODE* AddChild(NODE* pPar,int nVal,const char *pPath)
{//如果pPar为0，则初始化
    if(pPar==0)
        pPar=new NODE(NullNode);
    switch(*pPath)
    {
        case ')':pPar->nVal=(pPar->nVal==0 && nVal!=0)?nVal:-1;break;
//左子孙
        case 'L':pPar->pL=AddChild(pPar->pL,nVal,pPath+1);break;
//右子孙  
      case 'R':pPar->pR=AddChild(pPar->pR,nVal,pPath+1);break;
    }
    return pPar;
}

int main()
{
    NODE* pRoot=0;
    
    for(string strToken;cin>>strToken;)
    {
        const char *pStr=strToken.c_str(); //超赞的方法
        int nVal=0;
        
        if(pStr[1]!=')')
        {
            for(;isdigit(*++pStr);nVal=nVal*10+*pStr-'0');
            if(*pStr!=',') while(true);  //报错，如果不是','则lld输入不正确
            pRoot=AddChild(pRoot,nVal,++pStr);
            continue;
        }
        //层次遍历用链表存储树，如果遍历到尾部，继续返回首部遍历
       //并在原地插入子孙节点
        list<NODE*> Level(1,pRoot);
        stringstream ss;
        for(list<NODE*>::iterator it=Level.begin();!Level.empty();
            it=(it==Level.end()?Level.begin():it))
        {
            NODE* pTemp=*it;
            it=Level.erase(it);
            
            if(pTemp==0)
                continue;
            if(pTemp->nVal<=0)
            {
                Level.clear();
                ss.str("");
                break;
            }
                ss<<pTemp->nVal<<' ';
                it=Level.insert(it,pTemp->pL),++it;
                it=Level.insert(it,pTemp->pR),++it;
            
        }
        DeleteTree(pRoot);
        pRoot=0;
        strToken=ss.str();
        if(strToken.empty())
        {
            strToken="not complete";
        }
        else
        {
            strToken.erase(strToken.end()-1);
        }

        cout<<strToken<<endl;
    }
    return 0;
}

#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <sstream>
#include <vector>
#include <map>

using namespace std;


struct Node
{
    int id;
    string routine;
    Node(int x,string str):id(x),routine(str){}
    bool operator<(const Node& n)const
    {
        if(routine.size()<n.routine.size()) return true;
        else if(routine.size()==n.routine.size()) return routine<n.routine;
        else return false;
    }
};


string str;
map<string,int> mp;
vector<Node> vt;

bool Input()
{
    mp.clear();
    vt.clear();
    bool input=false;
    while(cin>>str and str!="()")
    {
        input=true;
        stringstream ss(str);
        char ch;int x;string tmp;
        ss>>ch>>x>>ch>>tmp;
        tmp.erase(tmp.size()-1);
        vt.push_back(Node(x,tmp));
    }
    return input;
}

inline string Parent(string &str)
{
    return str.substr(0,str.size()-1);
}

int main()
{
    while(Input())
    {
        sort(vt.begin(),vt.end());
        bool NO=vt[0].routine!="";
        mp[""]=1;
        for(int i=1;i<vt.size() and !NO;i++)
        {
            string par=Parent(vt[i].routine);
            if(mp.count(par)==0 or mp.count(vt[i].routine)!=0)
            {
                NO=true;
                break;
            }
            mp[vt[i].routine]++;
        }
        
        if(NO)
            cout<<"not complete"<<endl;
        else
        {
            for(int i=0;i<vt.size()-1;i++)
                cout<<vt[i].id<<" ";
            cout<<vt.back().id<<endl;
        }
    }
    return 0;
}