05-树与二叉树 二叉树的建立与遍历

Time Limit: 1 Second(s)    Memory Limit: 32 MB

Total Submission(s): 567   Accepted Submission(s): 389
 
Problem Description 
 
从键盘输入一个字符序列，用先序序列建立二叉树，输出该二叉树的中序、后序遍历序列。

Input

测试数据有多组，处理到文件尾。每组测试数据在一行中输入不含空格的不超过80个字符的字符序列，表示用先序序列建立二叉树的序列，其中字符‘*’表示对应的子树为空。

Output

对于每组测试，分别在两行输出所建立二叉树的中序遍历序列和后序遍历序列。
Sample Input 
HDA**C*B**GF*E***
Sample Output 
ADCBHFEG
ABCDEFGH
 
#include<iostream>
#include<stack>
#include<string>
using namespace std;
struct BiTNode
{
    char date;
    BiTNode *lchild,*rchild;
    
    BiTNode(char ch,BiTNode *left,BiTNode *right)
    {
        date=ch;
        lchild=left;
        rchild=right;
    }
    BiTNode(){}
};

//先序遍历
void PreOrder(BiTNode *T)//递归调用 
{
    if(T) 
    {
        cout<<T->date;
    PreOrder(T->lchild);
    PreOrder(T->rchild);
    }
 } 
//中序遍历
void InOrder(BiTNode *T)
{
    if(T)
    {
        InOrder(T->lchild);
        cout<<T->date;
        InOrder(T->rchild);
    }
 } 
 
 //后序遍历
void PostOrder(BiTNode *T)
{
    if(T)
    {
        PostOrder(T->lchild);
        PostOrder(T->rchild);
        cout<<T->date;
    }
 } 
//非递归实现中序遍历
void InOrder1(BiTNode *T)
{
    BiTNode *p=T;
    stack <BiTNode*> S;
    while(p!=NULL||!S.empty())
    {
        if(p!=NULL)
        {
            S.push(p);
            p=p->lchild;
        }
        else
        {
            p=S.top();
            S.pop();
            cout<<p->date;
            p=p->rchild;
        }
    }
 } 
//计算叶子结点
int  CountLeaf(BiTNode *T)
{
    if(T==NULL) return 0;
    
    BiTNode *p=T;
    int cnt=0;
    if(p->lchild==NULL&&p->rchild==NULL) cnt=1;
    cnt+=CountLeaf(p->lchild);
    cnt+=CountLeaf(p->rchild);
    return cnt;
    
}
//求二叉树的深度
  int Depth(BiTNode *T)
  {
      if(!T) return 0;
      
      int depthleft= Depth(T->lchild);
      int depthright=Depth(T->rchild);
      int val=1+max(depthleft,depthright);
     return val; 
  }
//递归法创建二叉树,
 BiTNode* CreateBiTree(string &s)
 {
     if(s[0]=='*')
     {
         s=s.substr(1);
         return NULL;
    }
    BiTNode *p=new BiTNode;
    p->date=s[0];
    s=s.substr(1);
    p->lchild=CreateBiTree(s);
    p->rchild=CreateBiTree(s);
    return p; 
 }
 
int main()
{
    string s;
    while(cin>>s)
    {
        BiTNode *root=CreateBiTree(s);
        PreOrder(root);
        cout<<endl;
        PostOrder(root);
        cout<<endl;
    }
    return 0;
}

 

 

 

 

06-图 畅通工程（1）
Time Limit: 1 Second(s)    Memory Limit: 32 MB
Total Submission(s): 677   Accepted Submission(s): 373
Problem Description 

某省调查城镇交通状况，得到现有城镇道路统计表，表中列出了每条道路直接连通的城镇。省政府“畅通工程”的目标是使全省任何两个城镇间都可以实现交通（但不一定有直接的道路相连，只要互相间接通过道路可达即可）。问最少还需要建设多少条道路？ 
Input

测试输入包含若干测试用例。每个测试用例的第1行给出两个正整数，分别是城镇数目N ( < 1000 )和道路数目M；随后的M行对应M条道路，每行给出一对正整数，分别是该条道路直接连通的两个城镇的编号。为简单起见，城镇从1到N编号。 
注意:两个城市之间可以有多条道路相通,也就是说
3 3
1 2
1 2
2 1
这种输入也是合法的
当N为0时，输入结束，该用例不被处理。 
Output

对每个测试用例，在1行里输出最少还需要建设的道路数目。 
Sample Input
4 2
1 3
4 3
0
Sample Output
1
Source

浙大计算机研究生复试上机考试-2005年

 

#include<iostream>
using namespace std;
const int N=1001;
int P[N];//父节点编号从一开始用 
void Init(int n)//每个节点作为一个集合 
{
    for(int i=1;i<=n;i++)
    {
        P[i]=i;
    }
}

int Find(int x)//查找函数 
{
    int y=x;
    while(P[x]!=x)//查找根 
    {
        x=P[x];
    }
    
    while(y!=x)//路径压缩 
    {
        int t=P[y];
        P[y]=x;
        y=t;
    }
    return x;
 } 


bool Union(int x,int y)//并操作 
{
    int fx,fy;
    fx=Find(x);
    fy=Find(y);
     if(fx==fy) return false;
     P[fy]=fx;
     return true;
}
bool run()
{
    int n,m,i;
    cin>>n;
    if(n==0) return false;
    Init(n);
    cin>>m;
    for(i=0;i<m;i++)
    {
        int x,y;
        cin>>x>>y;
        Union(x,y);
    }
    int cnt=0;
    for(i=1;i<=n;i++)
    {
        if(P[i]==i) cnt++;
    }
    cout<<cnt-1<<endl;
    return true;
 } 
int main()
{
    while(run());
}