//（1）能进行初始化；即在算法中用双亲数组完成树的存储
//（2）输入任一结点，求其在数组中的存储位置
//（3）输入一结点，求其双亲
//（4）输入一结点，求其孩子
//（5）输入一结点，求其度(选作)
帮我写写······
希望有注释······

补充一下：
typedef char elemtype;
typedef struct
{
    elemtype data;
    int parent;
}pnode;
typedef struct
{
    pnode nodes[maxsize];
    int num;
}psqtree;
后面不知道了······

这个代码我写过，你可以参考下，提醒你代码还是自己写比较好：
#ifndef PTREE_H
#define PTREE_H

#include<iostream.h>
#include<stdlib.h>
#include"LinkedStack.h"
#include"LinkedQueue.h"
#define defaultSize 20

////////////////////////////////////////////////
//采用父结点表示法的树的结点结构
////////////////////////////////////////////////
template<class T>
struct PTreeNode
{
    T data;                        //结点的数据域
    int parent;                    //父结点的指针
    PTreeNode(T val=-2,int par=-2) //构造函数
    {data=val;parent=par;};
};
////////////////////////////树的结点结构定义结束

////////////////////////////////////////////////
//PTree类模板用父结点表示法实现的树类
////////////////////////////////////////////////
template<class T>
class PTree
{
public:
    PTreeNode<T>* NodeList; //树的顺序存储的结点数组
    int size;               //当前树的结点的最后位置
    int current;            //当前结点的指针
    int maxSize;            //默认的最大数组空间
public:
    PTree(char* s,int n);   //构造函数,通过广义表描述字符串创建
    ~PTree()                //析构函数,释放结点数组的内存空间
    {delete [] NodeList;};  
    void Display();         //显示当前树的存储结构的内容

    int FindParent(int i)                  //找出当前结点的父结点指针
    {return NodeList[i].parent;};
    int FindFirstChild(int i);             //找出当前结点i的长子结点
    int FindNextSibling(int i);            //找出当前结点的相邻的兄弟结点
    int NearestCommonAncestor(int p,int q);//找p和q的最近公共祖先结点
    int CountLeaf();                       //计算当前树的叶子结点的个数
    int Depth();                           //求出当前树的深度
};
/////////////////////////////PTree类模板声明结束

////////////////////////////////////////////////
//构造函数 通过广义表描述字符串创建树
////////////////////////////////////////////////
template<class T>
PTree<T>::PTree(char* s,int n)
{
    //计算要开辟的内存空间的个数
    maxSize=n>defaultSize?n:defaultSize;
    //为结点数组开辟内存空间,需要结点结构默认构造函数
    NodeList=new PTreeNode<T>[maxSize];
    //初始化数据成员
    current=0;
    size=-1;
    //标志
    int flag=0;
    //结点指针堆栈
    LinkedStack<int> LS;
    //用于存放栈顶的指针
    int top;

    //通过描述字符串建立一棵树
    int i=0;
    while(s[i]!='#')
    {
        switch(s[i])
        {
        case '(':
            //进入子树,把父结点的指针入栈
            LS.Push(size);
            flag=1;
            break;
        case ',':
            //表示是从栈顶获取的父结点指针
            flag=1;
            break;
        case ')':
            //退栈
            LS.Pop(top);
            flag=1;
            break;
        default:
            {
            //数组指针向后推进一格
            size++;
            //送入数据域
            NodeList[size].data=s[i];
            //如果是根结点,则父结点为-1
            if(flag==0)
                NodeList[size].parent=-1;
            //如果是分支结点,从堆栈中获取父结点指针
            else if(flag==1)
            {
                LS.getTop(top);
                NodeList[size].parent=top;
            }
            break;
            }
        }
        i++;
    }
};
//////////////////////通过广义表描述字符串创建树

////////////////////////////////////////////////
//Display()公有成员函数
////////////////////////////////////////////////
template<class T>
void PTree<T>::Display()
{
    for(int i=0;i<=size;i++)
        cout<<i<<":"<<NodeList[i].data<<" "
            <<NodeList[i].parent<<endl;
};
///////////////////////////Display()公有成员函数

////////////////////////////////////////////////
//FindFirstChild()公有成员函数
//找出当前结点i的长子结点的指针,如果没有就返回-1
////////////////////////////////////////////////
template<class T>
int PTree<T>::FindFirstChild(int i)
{
    //因为结点的顺序是前序序列,所以如果有长子结点
    //那肯定就在i结点的下个相邻结点
    //如果该结点没有子结点
    if(NodeList[i+1].parent!=i)
        return -1;
    else
        //否则下个结点就是其长子结点
        return i+1;
};
////////////////////////FindFirstChild()函数结束

////////////////////////////////////////////////
//FindNextSibling()公有成员函数
//找出当前结点i的下个兄弟结点,如果没有就返回-1
////////////////////////////////////////////////
template<class T>
int PTree<T>::FindNextSibling(int i)
{
    //寻找第一个和当前结点i有相同父结点的结点
    for(int j=i+1;j<=size;j++)
        if(NodeList[j].parent==NodeList[i].parent)
            return j;
    //没有找到
    return -1;
};
///////////////////////FindNextSibling()函数结束

////////////////////////////////////////////////
//NearestCommonAncestor()公有成员函数
//找结点p和结点q的最近公共祖先结点
////////////////////////////////////////////////
template<class T>
int PTree<T>::NearestCommonAncestor(int p,int q)
{
    //定义两个堆栈,存放p,q两个结点的所有祖先结点
    LinkedStack<int> S1,S2;
    //保证p在前
    if(p>q)
    {
        int t;t=p;p=q;q=t;
    };
    //寻找结点p和q的最近公共祖先结点
    //首先找出p的所有祖先结点
    while(p!=-1)
    {
        //p指针向上指向其父结点
        p=NodeList[p].parent;
        //把每次的父结点指针压入队列Q1
        S1.Push(p);
    }
    //再找出q的所有的祖先结点
    cout<<endl;
    while(q!=-1)
    {
        //q指指针向上指向其父结点
        q=NodeList[q].parent;
        //把每次的父结点压入队列Q2
        S2.Push(q);
    };
    //从队列Q1和Q2头部开始找最先相同的结点指针
    do
    {
        //分别从对头取两个指针
        S1.Pop(p);
        S2.Pop(q);
    }
    while(p==q && !S1.IsEmpty() && !S2.IsEmpty());
    //最后得到的是两者的最近公共祖先
    return p;
};
/////////////////NearestCommonAncestor()函数结束

////////////////////////////////////////////////
//CountLeaf()公有成员函数
//计算当前树中叶子结点的个数
//作于09年1.16
////////////////////////////////////////////////
template<class T>
int PTree<T>::CountLeaf()
{
    int p=0;                   //计数器
    int f=1;                   //是否是叶子结点的标记变量
   
    for(int i=0;i<=size;i++)   //遍历数组的所有结点
    {
        f=1;
        for(int j=0;j<=size;j++)
        {
            if(NodeList[j].parent==i)
            {
                f=0;           //不是叶子结点
                break;
            };
        };
        if(f==1)
            p++;               //是叶子结点
    };
    return p;
};
/////////////////////////////CountLeaf()函数结束

////////////////////////////////////////////////
//Depth()公有成员函数
//求出当前二叉树的深度,算法思想:从每个结点出发,
//向根结点迈进,计算每个结点的最大层次数就是深度
////////////////////////////////////////////////
template<class T>
int PTree<T>::Depth()
{
    int depth=0;
    for(int i=0;i<=size;i++)     //遍历结点数组里的所有结点
    {
        int p=i,count=1;
        while(p!=0)              //从结点i往根迈进
        {
            p=NodeList[p].parent;//求出结点i所在的层次
            count++;
        };
        if(depth<count)          //保留最大结点层次数
            depth=count;
    };
    return depth;
};
/////////////////////////////////Depth()函数结束

#endif

你写的很复杂····
我不是刚学·····不过还是谢谢！！！
代码：
/*完成树的顺序存储结构（双亲数组法）实现。完成如下功能：
（1）能进行初始化；即在算法中用双亲数组完成树的存储
（2）输入任一结点，求其在数组中的存储位置
（3）输入一结点，求其双亲
（4）输入一结点，求其孩子
（5）输入一结点，求其度(选作)*/
//定义树变量：psqtree  t1;
//输入树中结点个数：cin>>t1.num;
//输入树中第i个结点的数据元素的值：
//cin>>t1.nodes[i].data
//输入第i个元素的双亲的下标
#include"iostream.h"
typedef char elemtype;
#define maxsize 10
typedef struct
{
    elemtype data;//数据元素的值
    int parent;//双亲结点下标位置
}pnode;//一个数据结点的类型
typedef struct
{
    pnode nodes[maxsize];//结构体数组，每一个元素有两个成员，data，parent
    int num;//树中结点的个数
}psqtree;//树的顺序存储结构类型
void createtree(psqtree  &t1)
{
  cout<<"输入结点的个数:";//输入结点个数，初始化num
      cin>>t1.num;
    for(int i=1;i<=t1.num;i++)
     {
        cin>>t1.nodes[i].data;
        cin>>t1.nodes[i].parent;
  }
}
int  arraylocation(psqtree &t1,elemtype e)//输入任一结点e，求其在数组中的存储位置i
{
    int i=1;
    while(t1.nodes[i].data!=e)
    {
        i++;
    }
    return i;
}
void getparent(psqtree &t1,elemtype e)//输入一结点，求其双亲
{
    int i=1;
    while(t1.nodes[i].data!=e)
    {
        i++;
    }
    cout<<t1.nodes[t1.nodes[i].parent].data;

}
void getsons(psqtree &t1,elemtype e)//输入一结点，求其孩子
{
    int i=1;
    while(t1.nodes[i].data!=e)

    {
        i++;
    }
    for(int j=1;j<=t1.num;j++)
    {
        if(t1.nodes[j].parent==i)
            cout<<t1.nodes[j].data;
    }

}

void getdu(psqtree &t1)
{
    int max=0;//结点子树的个数
    int i=-1;//结点的下标
        while(i<t1.num)
    {     int num=0;
         for(int j=1;j<=t1.num;j++)
        {
          if(t1.nodes[j].parent==i)
            num++;
         }
   
         if(max<num)
             max=num;
    i++;
    }
        cout<<max;
}


void dislist(psqtree  &t1)
{
 
    for(int i=1;i<=t1.num;i++)
     {
        cout<<t1.nodes[i].data;
       // cout<<t1.nodes[i].parent;
  }
}
void main()
{
psqtree t1;
createtree(t1);
dislist(t1);
elemtype e;
cout<<endl;
cout<<"输入结点为e的元素:";
cin>>e;
cout<<"数据的位置:"<<arraylocation(t1,e);
cout<<endl;
cout<<"输入结点为e的(求双亲):";
cin>>e;
getparent(t1,e);
cout<<endl;
cout<<"输入结点为e的(求孩子):";
cin>>e;
getsons(t1,e);   
cout<<endl;
cout<<"树的度为：";
getdu(t1);
}

我做的：
/*完成树的顺序存储结构（双亲数组法）实现。完成如下功能：
（1）能进行初始化；即在算法中用双亲数组完成树的存储
（2）输入任一结点，求其在数组中的存储位置
（3）输入一结点，求其双亲
（4）输入一结点，求其孩子
（5）输入一结点，求其度(选作)*/
//定义树变量：psqtree  t1;
//输入树中结点个数：cin>>t1.num;
//输入树中第i个结点的数据元素的值：
//cin>>t1.nodes[i].data
//输入第i个元素的双亲的下标


#include"iostream.h"
#define maxsize 20
typedef char elemtype;
typedef char tsbnode;
typedef struct       //双亲存储结构
{
    elemtype data;  //数据元素的值
    int parent;     //双亲结点下标
}pnode;             //一个结点结构            
typedef struct      //孩子链存储结构
{
    pnode nodes[maxsize];   //结构体数组，每一个元素有两个成员，data，parent
    int num;                //树中结点的个数
}psqtree;                   //树的顺序存储结构类型
  
void createtree(psqtree  &t1)    //能进行初始化；即在算法中用双亲数组完成树的存储
{
    int i;               
    for(i=1;i<=t1.num;i++)      //依次输入元素的值，初始化数组nodes[]
    {
        cout<<"输出第"<<i<<"存储元素的值和下标：";
        cin>>t1.nodes[i].data;
        cin>>t1.nodes[i].parent;
    }
}

void gettree(psqtree &t1,elemtype e)     //输入任一结点值，求其在数组中的存储位置
{
    int i=1;
    while(e!=t1.nodes[i].data)
    {
        i++;
    }
    if(i>t1.num)
        cout<<"无此结点!"<<endl;
    else
        cout<<i<<endl;
}

void gettreel(psqtree &t1,elemtype e)    //输入一结点值，求其双亲
{
    int i;
    cout<<"输入一结点：";  
    cin>>e;
    while(e!=t1.nodes[i].data)
    {
        i++;
    }
    if(t1.nodes[i].data==t1.nodes[0].data)
    {
        cout<<"此结点为根节点，没有双亲!"<<endl;
    }
    else
    {
        if(i>t1.num)
        {
            cout<<"无此结点!"<<endl;
        }
        else
        {
            cout<<"其双亲元素的值为："<<endl;
            cout<<t1.nodes[t1.nodes[i].parent].data<<endl;
        }
    }
}

void gettree2(psqtree  &t1,elemtype e)   //输入一结点，求其孩子
{
    int i=1;
    cout<<"输入一结点：";  
    cin>>e;
    int j=0;
    while(t1.nodes[i].data!=e)
    {
        i++;
    }
    while(j<t1.num)   
    {
        if(t1.nodes[j].parent==i)
        {
            cout<<"子结点:"<<t1.nodes[j].data<<endl;
        }
        j++;
    }
}

void main()
{
    psqtree  t1;             //定义树变量
    elemtype e;
    cout<<"输出结点个数：";    //输入结点个数，初始化num
    cin>>t1.num;  
    createtree(t1);
    cout<<"输入任意一结点值：";  
    cin>>e;
    cout<<"存储的位置是："<<endl;
    gettree(t1,e);
    gettreel(t1,e);
    gettree2(t1,e);
}

较经典的：
#include"iostream.h"
#include <stdlib.h>
typedef char elemtype;
class pnode
{
public:
    elemtype data;
    int parent;
};//一个结点结构
class psqtree
{
    pnode nodes[50];
    int num;
public:
    void init();//初始化
    int locateelem(char p);//求结点位置
    void findparent(char p);//求双亲
    void findchild(char p);//求孩子和度
    };//树的顺序存储结构类型
void  psqtree::init()      
    {
        int i,m;
        char e;
        cout<<"请输入节点个数:";cin>>num;
        for(i=0;i<num;i++)
        {
            cout<<"请输入节点"<<i+1<<"的值(字母):";cin>>e;nodes[i].data=e;
            cout<<"请输入节点"<<i+1<<"双亲的下标:";cin>>m;nodes[i].parent=m;
        }
        cout<<endl;
    }
int psqtree::locateelem(char p)   
{
      int i=0;
      while(nodes[i].data!=p)
          i++;
      if(i>num) {cout<<"无此值的结点，自己看清楚点啊- -||\n";return 0;}
      else {cout<<"节点的位置:"<<i+1<<endl;return 1;}
}
void psqtree::findparent(char p)
{
    int i=0;
      while(nodes[i].data!=p)
          i++;
      if(nodes[i].data==nodes[0].data) cout<<"该结点是根节点，没有双亲的啦- -||\n";
      else
      {
      if(i>num) cout<<"无此值的结点，自己看清楚点啊- -||\n";
      else cout<<"双亲求到啦:"<<nodes[nodes[i].parent-1].data<<endl;
      }
}
void psqtree::findchild(char p)  
{
    int i=0,j=0,m=0;
      while(nodes[i].data!=p)
          i++;
      i++;
      while(j<num)   
     {
          if(nodes[j].parent==i) {cout<<"子结点:"<<nodes[j].data<<endl;m++;}
         j++;
     }
    if(!m) cout<<"sorry,这个结点没有孩子\n";
      cout<<"该结点的度:"<<m<<endl;
}
int main()
{
    psqtree s;
    s.init();
    char reply='y';
    while(reply=='y')
    {
    system("cls");   
    cout<<"查找结点:";char p;cin>>p;
    //s.locateelem(p);
    if(s.locateelem(p))
    {s.findparent(p);
    s.findchild(p);}
    cout<<"继续功能测试吗(y/n):";
    cin>>reply;
    cout<<endl;
    }
    return 1;
}