【C/C++】實現數據結構廣義表

1. 廣義表的定義
     每個元素可以為Atom，原子，也可以為線性表。
     線性表的推廣。線性表元素有唯一的前驅和后繼，為線性表，而廣義表是多層次的線性表
     表頭：第一個元素，可能是原子，可能是廣義表
     表尾：除了第一個元素，剩余的元素，所構成的廣義表
     舉例：
         A = (a,b,(c,d),e)
         head(A)  = a
         tail(A) = (b,(c,d),e)
     遍歷操作：
     取表頭，取表尾 ，取表頭..
     長度：最外層的元素數，即最外層的','+1
     深度：括號層數
  2. 廣義表的兩種存儲結構（子表法）
 
      2.1鏈式存儲結構 - 每個數據元素可以用一個節點表示
         元素可以為原子或列表
         原子節點：標志域、值域
         列表節點：標志域、指示表頭的指針域、指示表尾的指針域
         空表：A = NULL
         除了空表，表頭指針指向一個表節點，表節點再分表頭、表尾...
         最高層表節點(可能原子、子表)的個數就是表長度? A = (a,b,(c,d),e) 最高層表頭是先a,表尾是(b,(c,d),e)，表頭是b,表尾((c,d),e)..就是第一層的表尾直到為空之前，有過的表尾指針+1
         判斷是否在同一層次？
             是這樣的： 最高層處於同一層，后繼的tail指針指向的是同一層，否則，head指針，或者表頭是Atom，都是下一層。
     2.2擴展線性表存儲結構
         不是用表頭表尾指針了，而是，每一個節點，不管是子表還是原子，都有一個指向本子表下一個元素的next指針
         A = (a,b,(c,d))
         A -> |1,HP,TP|
                 |    |
                 a -> b -> (c,d)
                             |
                             c -> d

下面，實現了廣義表的兩種定義，以及基於遞歸的一些操作。

#include<bits/stdc++.h>
#define AtomType int
typedef enum{ATOM,LIST}ElemTag; //ATOM = 0：原子；LIST = 1:子表 
/*線性表存儲之鏈式*/
typedef struct GLNode{
    ElemTag tag; //枚舉類型的標志域，只能取定義了的枚舉值
    union{      //union聯合體，下面兩部分只能取其一；要么取AtomType;要么取結構體ptr,ptr包括兩個指針hp,tp 
        AtomType atom;
        struct{
            struct GLNode *hp,*tp;
        }ptr;
    }; 
}*GList; //定義廣義表類型，GList為指針 

/*線性表存儲之擴展線性表 = 子表法*/ 
typedef struct GLNode2{
    ElemTag tag;
    union{
        AtomType atom;
        struct GLNode2 *hp;     //對於原子，tp就是指向其相同層次的下一個元素 
                             //對於列表，hp指向本列表內部第一個元素，而tp是指向本層次上的下一個元素 
    };
    struct GLNode2 *tp;
} *GList2;
/*
*    討論廣義表的遞歸算法 ： 分治法進行遞歸算法設計
*    1. 問題可拆解成子問題，與原問題性質相同，規模變小
*    2. 有遞歸終止條件 
*/ 

/*求廣義表的深度 - 采用鏈式存儲結構時 
*    廣義表的深度：（）的重數  空表() 深度為1.原子深度為0 
*    
*/
int GListDepth(GList L) {
    if(!L) return 1; //空表1
    if(L->tag ==ATOM ) return 0;
    GList pp;
    //遍歷同一層，遞歸下一層，取表尾，取表頭，第一步先去一個表頭 
    int max;
    for(max = 0, pp =L;pp!=NULL;pp = pp->ptr.tp){
        int dep = GListDepth(pp->ptr.hp) ;
        if(dep > max) max = dep; //這一步比較，是比較同一層的depth 
    }
    return max+1;
}
//練習
int depth_my(GList L) {
    if(L == NULL){
        return 1;
    }
    if(L->tag == ATOM){
        return 0;
    }
    int max = 0;
    GList pp;
    for(max = 0,pp=L;pp!=NULL;pp = pp->ptr.tp){
        int dep = depth_my(pp->ptr.hp);
        if(dep >max) max = dep;
    }
    return max+1;
}

/*
    求Depth2 == 子表法求dep 
*/
int GListDepth_2(GList2 L){
    if(L == NULL) return 1;
    if(L->tag == ATOM) return 0;
    int max = 0;
    GList2 pp;
    for(max = 0,pp=L->hp;pp!=NULL;pp = pp->tp){
        int dep = GListDepth_2(pp);
        if(dep >max) max = dep;
    }
    return max+1;
}
/*********************分界*****************************/
/*
*    復制廣義表：copy深復制 -- 鏈式存儲 
*    分別復制表頭、表尾，然后合成即可==遞歸 
*/
void CopyGList(GList &T,GList L) { 
    //頭尾鏈表存儲，將L賦值給T 
    if(!L) T = NULL; //空 
    else{
        //創建一個節點 ，這個節點要么是ATOM，要么是廣義表 
        T = (GList)malloc(sizeof(GLNode));
        if(!T) exit(0);
        T->tag = L->tag;
        if(L->tag == ATOM) //是原子的話，復制原子 
            T->atom = L->atom; 
        //復制廣義表
        else{
            //分別復制表頭和表尾 
            CopyGList(T -> ptr.hp,L->ptr.hp);
            CopyGList(T->ptr.tp,L->ptr.tp);
        } 
    }
}
//練習
void copy_my(GList&T,GList L) {
    if(L == NULL) T = NULL;
    else{
        T = (GList)malloc(sizeof(GLNode));
        if(!T) exit(0);
        T -> tag = L -> tag;
        if(L->tag == ATOM){
            T->atom = L->atom;
        }else{
            copy_my(T -> ptr.hp,L->ptr.hp);
            copy_my(T ->ptr.tp,L->ptr.tp);
        }
    }
}
/**********************分割線*************************/
/*
*    創建一個廣義表：必考內容 
*    廣義表的書寫，看成一個字符串S
*    下面頭尾鏈表法創建一個廣義表 
*/ 
using namespace std;
string emp = "()" ;

void sever(string &str,string &hstr){
    //將非空串str分割成兩部分，hstr是表頭
    int n = str.size();
    int i = -1;
    int k = 0; //k記錄尚未配對的“(” 數
    char ch;    
    do{ //搜索最外層第一個( 
        ++i;
        ch = str[i];
        if(ch == '(') ++k;
        else if(ch == ')') --k;
    }while(i<n&&(ch != ','||k!=0));
     if(i<n){
         hstr =str.substr(0,i);
         //printf("in\n");
         str = str.substr(i+1,n-i-1);
         //printf("out\n");
     }else{
         hstr = str.substr(0,str.size());
         str.clear();
     }
}

void CreateGList(GList &L,string s){
    //采用頭尾鏈表存儲結構，創建L
    if(s.compare(emp) == 0) L = NULL;
    else{
        L = (GList)malloc(sizeof(GLNode));
        if(!L) exit(0);
        if(s.size() == 1){ //單個元素，建立原子節點 
            L->tag = ATOM;
            L->atom = s[0];
        }else{ //表節點 ,表尾 
            L->tag = LIST;
            GList p,q;
            p = L; //p是指向當前子表(表尾節點)的指針 
            string sub;
            sub = s.substr(1,s.size()-2); //去掉外層括號 
            string hsub;
            do{ //重復建立n個子表 
                sever(sub,hsub); //sub中分理出表頭串hsub ，同時，sub去除了hsub
                CreateGList(p->ptr.hp,hsub);
                q = p; //記錄p，下面sub不為空，要再建立一個表尾節點，q記錄上一層的p，用以連接q->ptr.tp = q 
                if(!sub.empty()) {
                    p = (GList)malloc(sizeof(GLNode));
                    if(!p)exit(0);
                    p -> tag = LIST;
                    q -> ptr.tp = p;
                }//if
            }while(!sub.empty());
            q -> ptr.tp = NULL;
        //    printf("has complete\n");
        }
    }
}
 

int main(){
//    string s = "1232342342";
//    if(s.compare("123") == 0){
//        printf("13");
//    }
//    printf("\n");
//    s = s.substr(1,s.size()-2);
//    for(int i = 0;i<s.size();i++){
//        printf("%c",s[i]);
//    }
    
    string ss = "(2,3,4,(1,2))";
    GList L;
    CreateGList(L,ss);
    printf("深度：");
    printf("%d",GListDepth(L));
    return 0;
}