【王道数据结构编程题】 - 链表代码题

目录

1.设计一个递归算法，删除不带头节点的单链表L中所有值为x的节点。

2.在带头节点的单链表L中，删除所有制为x的节点，并释放其空间，假设置为x的节点不唯一，试编写算法以实现上述操作。

3.设L为带头节点的单链表，编写算法实现从尾到头反向输出每个节点的值。

4.试编写在带头节点的单链表L这删除一个最小值节点的高效算法(假设最小值节点是唯一的)。

5.试着编写算法将带头节点的单链表就地逆置，所谓“就地”就是辅助空间复杂度为O(1)。

6.有一个带头节点的单链表L，设计一个算法使其元素递增有序。

7.设在一个带表头节点的单链表中所有元素节点的数据值无序，试编写一个函数，删除表中所有介于给定的两个值(作为函数参数给出)之间的元素的元素(若存在)。

8.给定两个单链表，编写算法找出两个链表的公共节点。

9.给定一个带表头节点的单链表，设head为头指针，节点结构为(data , next)，data为整型元素，next为指针，试着写出算法：按递增次序输出单链表中各个节点的数据元素，并且释放节点所占的存储空间(要求：不允许使用数组作为辅助空间)。

10.将一个带头节点的单链表A分解为两个带头节点的单链表A和B，使得A表中含有原表中序号为奇数的元素，而B表中含有原表中序号为偶数的元素，且保持其相对顺序不变。

11.设C={a1,b1,a2,b2,...,an,bn}为线性表，采用带头节点的hc单链表存放，设计一个就地算法，将其拆分为两个线性表，使得A={a1,a2,...,an}，B={bn,...,b2,b1}。 

12.在一个递增有序的线性表中，有数值相同的元素存在。若存储方式为单链表，设计算法去掉数值相同的元素，使得表中不再有重复的元素，例如{7,10,10,21,30,42,42,42,51,70}将其变为{7,10,21,30,42,51,70}。 

13假设有两个按元素值递增次序排列的线性表，均以单链表形式存储，请编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表，并要求利用原来的两个单链表的节点存放归并后的单链表。 

14.设A和B是两个单链表(带头节点)，其中元素递增有序。设计一个算法从A和B中的公共元素产生单链表C，要求不破坏A,B的节点。 

15.已知两个链表A和B分别表示两个集合，其元素递增排列。编制函数，求A与B的交集，并存放于A链表中。 

16.两个整数序列A=a1,a2,...,am，B=b1,b2,...,bn。已经存入两个单链表中，设计一个算法，判断序列B是否是序列A的连续子序列。 

17.设计一个算法用于判断带头节点的循环双链表是否对称。 

18.有两个循环单链表，链表头指针分别为h1和h2，编写一个函数将链表h2链接到链表h1之后，要求链接后的链表仍保持循环链表形式。 

---

其他-王道算法题(可以运行)-链表如下

【王道数据结构与算法】- 链表算法题

1.设计一个递归算法，删除不带头节点的单链表L中所有值为x的节点。

代码实现：

//不带头结点的链表数据删除
#include
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode;
int a[4]={1,3,3,4};
int n=4;
void buildlist(lnode *L)
{
    lnode *s,*r=L;
    r->data=a[0];
    if(n==1) r->next=NULL;
    else{
        for(int i=1;idata=a[i];
            r->next=s;
            r=r->next;
        }
        r->next=NULL;
    }
}
void disp(lnode *L)
{
    lnode *s=L;
    while(s)
    {
        cout<<(s->data)<<" ";
        s=s->next;
    }
    cout<data==x)
    {
        p=L;
        L=L->next;
        free(p);
        deletex(L,x);
    }
    else deletex(L->next,x);
}
int main()
{
    lnode list;
    lnode *L=&list;
    buildlist(L);
    disp(L);
    deletex(L,3);//删除所有值为3的元素
    disp(L);
    return 0;
}

2.在带头节点的单链表L中，删除所有制为x的节点，并释放其空间，假设置为x的节点不唯一，试编写算法以实现上述操作。

代码实现：

//删除带头结点的链表中的节点
#include
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[4]={1,3,3,4};
int n=4;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    for(int i=0;idata=a[i];
        r->next=s;
        r=r->next;
		r->next=NULL;
    }
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<data<<" ";
        s=s->next;
    }
    cout<next,*q,*r=L;
    while(p)
    {
        if(p->data!=x)
        {
            r->next=p;
            r=p;
            p=p->next;
        }
        else
        {
            q=p;
            p=p->next;
            free(q);
        }
    }
}
int main()
{
    linklist L;
    buildlist(L);
    disp(L);
    deletex(L,3);//删除值为3的节点
    disp(L);
    return 0;
}

3.设L为带头节点的单链表，编写算法实现从尾到头反向输出每个节点的值。

代码实现：

//不带头结点的逆序输出
#include
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode;
int a[4]={1,2,3,4};
int n=4;
void buildlist(lnode *L)
{
    lnode *r=L,*s;
    r->data=a[0];
    if(n==1) r->next=NULL;
    else
    {
        for(int i=1;idata=a[i];
            r->next=s;
            r=r->next;
        }
        r->next=NULL;
    }
}
void disp(lnode *L)
{
    if(L!=NULL)
    {
        disp(L->next);
        cout<<(L->data)<<" ";
    }
    else return;
}
int main()
{
    lnode list;
    lnode *L=&list;
    buildlist(L);
    disp(L);
    return 0;
}

4.试编写在带头节点的单链表L这删除一个最小值节点的高效算法(假设最小值节点是唯一的)。

代码实现：

//带头结点的链表删除最小元素（唯一）
#include
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[4]={23,12,5,34};
int n=4;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *r=L,*s;
    for(int i=0;idata=a[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<data<<" ";
        s=s->next;
    }
    cout<next,*q,*r=L,*s;
    q=p,s=r;
    while(p)
    {
        if(p->datadata)
        {
            q=p;
            s=r;
        }
        r=p;
        p=p->next;
    }
    s->next=q->next;
    free(q);
}
int main()
{
    linklist L;
    buildlist(L);
    disp(L);
    deletemin(L);
    disp(L);
    return 0;
}

5.试着编写算法将带头节点的单链表就地逆置，所谓“就地”就是辅助空间复杂度为O(1)。

代码实现：

//头插法逆置链表
#include
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[4]={1,2,3,4};
int n=4;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *r=L,*s;
    for(int i=0;idata=a[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<data<<" ";
        s=s->next;
    }
    cout<next,*r;
    L->next=NULL;
    while(p)
    {
        r=p->next;
        p->next=L->next;
        L->next=p;
        p=r;
    }
}
int main()
{
    linklist L;
    buildlist(L);
    cout<<"逆置之前"<

6.有一个带头节点的单链表L，设计一个算法使其元素递增有序。

//链表的直接插入排序
#include
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[4]={3,7,4,9};
int n=4;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *r=L,*s;
    for(int i=0;idata=a[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<data<<" ";
        s=s->next;
    }
    cout<next,*r=p->next,*f;
    p->next=NULL;
    p=r;
    while(p)
    {
        r=p->next;
        f=L;
        while(f->next!=NULL&&f->next->datadata) f=f->next;
        p->next=f->next;
        f->next=p;
        p=r;
    }
}
int main()
{
    linklist L;
    buildlist(L);
    disp(L);
    sortlist(L);
    disp(L);
    return 0;
}

7.设在一个带表头节点的单链表中所有元素节点的数据值无序，试编写一个函数，删除表中所有介于给定的两个值(作为函数参数给出)之间的元素的元素(若存在)。

代码实现：

//删除链表区间内的结点
#include
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[5]={1,5,3,4,2};
int n=5;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    for(int i=0;idata=a[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<data<<" ";
        s=s->next;
    }
    cout<next,*r=L;
    while(p)
    {
        if(p->datadata>min)
        {
            r->next=p->next;
            free(p);
            p=r->next;
        }
        else
        {
            r=p;
            p=p->next;
        }
    }
}
int main()
{
    linklist L;
    buildlist(L);
    disp(L);
    deletelist(L,1,4);//删除1-4之间元素
    disp(L);
    return 0;
}

8.给定两个单链表，编写算法找出两个链表的公共节点。

代码实现：

//找公共结点
#include
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[5]={2,4,3,7,8};
int b[4]={1,3,7,8};
int n1=5,n2=4;
void buildlist(linklist &L,int aa[],int n)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    for(int i=0;idata=aa[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
int length(linklist L)
{
    int k=0;
    lnode *s=L->next;
    while(s)
    {
        k++;
        s=s->next;
    }
    return k;
}
linklist findd(linklist L1,linklist L2)
{
    int len1=length(L1),len2=length(L2);
    int dist=0;
    linklist long1,short1;
    if(len1>len2)
    {
        long1=L1->next;
        short1=L2->next;
        dist=len1-len2;
    }
    else
    {
        long1=L2->next;
        short1=L1->next;
        dist=len2-len1;
    }
    while(dist--) long1=long1->next;
    while(long1)
    {
        if(long1->data==short1->data&&long1->next->data==short1->next->data) return long1;
        else
        {
            long1=long1->next;
            short1=short1->next;   
        }
    }
    return NULL;
}
linklist findd2(linklist L1,linklist L2)
{
    lnode *s1=L1->next;
    while(s1)
    {
        lnode *s2=L2->next;
        while(s2)
        {
            if(s1->data==s2->data&&s1->next->data==s2->next->data)
            return s1;
            else s2=s2->next;
        }
        s1=s1->next;
    }
    return NULL;
}
int main()
{
    linklist L1,L2;
    buildlist(L1,a,n1);
    buildlist(L2,b,n2);
    linklist L3=findd2(L1,L2);
    cout<data<<" "<

9.给定一个带表头节点的单链表，设head为头指针，节点结构为(data , next)，data为整型元素，next为指针，试着写出算法：按递增次序输出单链表中各个节点的数据元素，并且释放节点所占的存储空间(要求：不允许使用数组作为辅助空间)。

代码实现：

//每次删除最小值且输出
#include
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[5]={2,5,3,8,1};
int n=5;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *r=L,*s;
    for(int i=0;idata=a[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void deletemin(linklist &L)
{
    while(L->next!=NULL)
    {
        lnode *r=L,*p=r->next;
        while(p->next!=NULL)
        {
            if(p->next->datanext->data)
                r=p;
            p=p->next;
        }
        cout<<(r->next->data)<<" ";
        lnode *q=r->next;
        r->next=q->next;
        free(q);
    }
    free(L);
}
int main()
{
    linklist L;
    buildlist(L);
    deletemin(L);
    return 0;
}

10.将一个带头节点的单链表A分解为两个带头节点的单链表A和B，使得A表中含有原表中序号为奇数的元素，而B表中含有原表中序号为偶数的元素，且保持其相对顺序不变。

代码实现：

//分链表
#include
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[5]={2,7,4,1,9};
int n=5;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *r=L,*s;
    for(int i=0;idata=a[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<data<<" ";
        s=s->next;
    }
    cout<next=NULL;
    lnode *r1=L1,*r2=L2,*p=L1->next;
    int i=0;
    L1->next=NULL;
    while(p)
    {
        i++;
        if(i%2==0)
        {
            r2->next=p;
            r2=p;
        }
        else
        {
            r1->next=p;
            r1=p;
        }
        p=p->next;
    }
    r1->next=NULL;
    r2->next=NULL;
}
int main()
{
    linklist L1;
    buildlist(L1);
    cout<<"之前"<

 

11.设C={a1,b1,a2,b2,...,an,bn}为线性表，采用带头节点的hc单链表存放，设计一个就地算法，将其拆分为两个线性表，使得A={a1,a2,...,an}，B={bn,...,b2,b1}。 

代码实现：

//链表拆分 头插法
#include
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[10]={1,2,3,4,5,6,7,8,9,10};
int n=10;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    for(int i=0;idata=a[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<data<<" ";
        s=s->next;
    }
    cout<next=NULL;
    lnode *p=L1->next,*q,*r=L1;
    while(p)
    {
        r->next=p;
        r=p;
        p=p->next;
        if(p!=NULL) q=p->next;
        p->next=L2->next;
        L2->next=p;
        p=q;
    }
    r->next=NULL;
}
int main()
{
    linklist L1;
    buildlist(L1);
    cout<<"一开始L1"<

 

12.在一个递增有序的线性表中，有数值相同的元素存在。若存储方式为单链表，设计算法去掉数值相同的元素，使得表中不再有重复的元素，例如{7,10,10,21,30,42,42,42,51,70}将其变为{7,10,21,30,42,51,70}。 

代码实现：

//链表的重复元素删除
#include
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[10]={7,10,10,21,30,42,42,42,51,70};
int n=10;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    for(int i=0;idata=a[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<data<<" ";
        s=s->next;
    }
    cout<next==NULL) return;
    lnode *p=L->next,*q;
    while(p->next!=NULL)
    {
        q=p->next;
        if(p->data==q->data)
        {
            p->next=q->next;
            free(q);
        }
        else p=p->next;
    }
}
int main()
{   
    linklist L;
    buildlist(L);
    cout<<"删除之前"<

 

13假设有两个按元素值递增次序排列的线性表，均以单链表形式存储，请编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表，并要求利用原来的两个单链表的节点存放归并后的单链表。 

代码实现：

//合并链表 递减
#include
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[4]={1,2,3,4};
int b[5]={3,4,5,6,7};
int n1=4,n2=5;
void buildlist(linklist &L,int aa[],int n)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *r=L,*s;
    for(int i=0;idata=aa[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<data<<" ";
        s=s->next;
    }
    cout<next,*p2=L2->next,*r;
    L1->next=NULL;
    while(p1&&p2)
    {
        if(p1->data<=p2->data)
        {
            r=p1->next;
            p1->next=L1->next;
            L1->next=p1;
            p1=r;
        }
        else
        {
            r=p2->next;
            p2->next=L1->next;
            L1->next=p2;
            p2=r;
        }
    }
    if(p1) p2=p1;
    while(p2)
    {
        r=p2->next;
        p2->next=L1->next;
        L1->next=p2;
        p2=r;
    }
    free(L2);
}
int main()
{
    linklist L1,L2;
    buildlist(L1,a,n1);
    buildlist(L2,b,n2);
    cout<<"L1:"<

 

14.设A和B是两个单链表(带头节点)，其中元素递增有序。设计一个算法从A和B中的公共元素产生单链表C，要求不破坏A,B的节点。 

代码实现：

//找共同元素 建立新链表
#include
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[4]={2,3,4,9};
int n1=4;
int b[5]={4,7,9,10,11};
int n2=5;
void buildlist(linklist &L,int aa[],int n)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    for(int i=0;idata=aa[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<data<<" ";
        s=s->next;
    }
    cout<next,*p2=L2->next,*s,*r;
    r=L3;
    while(p1&&p2)
    {
        if(p1->datadata) p1=p1->next;
        else if(p1->data>p2->data) p2=p2->next;
        else
        {
            s=(lnode *)malloc(sizeof(lnode));
            s->data=p1->data;
            r->next=s;
            r=s;
            p1=p1->next;
            p2=p2->next;
        }
    }
    r->next=NULL;

}
int main()
{
    linklist L1,L2;
    buildlist(L1,a,n1);
    buildlist(L2,b,n2);
    cout<<"L1:"<

 

15.已知两个链表A和B分别表示两个集合，其元素递增排列。编制函数，求A与B的交集，并存放于A链表中。 

代码实现：

//保留公共节点 其余删除
#include
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[4]={1,2,3,4};
int b[6]={2,4,5,6,7,8};
int n1=4,n2=6;
void buildlist(linklist &L,int aa[],int n)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    for(int i=0;idata=aa[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<data<<" ";
        s=s->next;
    }
    cout<next,*p2=L2->next,*r=L1,*q;
    while(p1&&p2)
    {
        if(p1->datadata)
        {
            q=p1;
            p1=p1->next;
            free(q);
        }
        else if(p1->data>p2->data)
        {
            q=p2;
            p2=p2->next;
            free(q);
        }
        else
        {
            r->next=p1;
            r=p1;
            p1=p1->next;
            q=p2;
            p2=p2->next;
            free(q);
        }
    }
    while(p1)
    {
        q=p1;
        p1=p1->next;
        free(q);
    }
    while(p2)
    {
        q=p2;
        p2=p2->next;
        free(q);
    }
    r->next=NULL;
}
int main()
{
    linklist L1,L2;
    buildlist(L1,a,n1);
    buildlist(L2,b,n2);
    cout<<"L1"<

 

16.两个整数序列A=a1,a2,...,am，B=b1,b2,...,bn。已经存入两个单链表中，设计一个算法，判断序列B是否是序列A的连续子序列。 

代码实现：

//判断是否是连续子序列
#include
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[6]={1,2,3,4,5,6};
int b[3]={3,4,5};
int n1=6,n2=3;
void buildlist(linklist &L,int aa[],int n)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    for(int i=0;idata=aa[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
bool isok(linklist L1,linklist L2)
{
    lnode *p1=L1->next,*p2=L2->next,*r=L1->next;
    while(p1&&p2)
    {
        if(p1->data!=p2->data)
        {
            r=r->next;
            p1=r;
            p2=L2->next;
        }
        else
        {
            p1=p1->next;
            p2=p2->next;
        }
    }
    if(p2) return false;
    else return true;
}
int main()
{
    linklist L1,L2;
    buildlist(L1,a,n1);
    buildlist(L2,b,n2);
    if(isok(L1,L2)) cout<<"yes"<

 

若 3 ， 4 ，7则不是

 

17.设计一个算法用于判断带头节点的循环双链表是否对称。
 

代码实现：

//判断循环双链表是否是对称的
#include
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next,*prior;
}lnode,*linklist;
int a[6]={1,2,3,3,2,1};
int n=6;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    L->prior=L;
    L->next=L;
    for(int i=0;idata=a[i];
        s->next=r->next;
        r->next->prior=s;
        s->prior=r;
        r->next=s;
        r=s;
        L->prior=s;
    }
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s!=L)
    {
        cout<data<<" ";
        s=s->next;
    }
    cout<next,*q=L->prior;
    while(p!=q&&q->next!=p)
    {
        if(p->data==q->data)
        {
            p=p->next;
            q=q->prior;
        }
        else return false;
    }
    return true;
}
int main()
{
    linklist L;
    buildlist(L);
    disp(L);
    if(isok(L))cout<<"yes"<

 

1,2,3,4,2,1很明显不对称

 

18.有两个循环单链表，链表头指针分别为h1和h2，编写一个函数将链表h2链接到链表h1之后，要求链接后的链表仍保持循环链表形式。 

代码实现：

//循环单链表的拼接
#include
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[4]={1,2,3,4};
int b[5]={5,6,7,8,9};
int n1=4,n2=4;
void buildlist(linklist &L,int aa[],int n)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    for(int i=0;idata=aa[i];
        r->next=s;
        r=r->next;
    }
    r->next=L;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s!=L)
    {
        cout<data<<" ";
        s=s->next;
    }
    cout<next,*q=L2->next;
    while(p->next!=L1)
    {
        p=p->next;
    }
    while(q->next!=L2){
        q=q->next;
    }
    p->next=L2->next;
    q->next=L1;
}
int main()
{
    linklist L1,L2;
    buildlist(L1,a,n1);
    buildlist(L2,b,n2);
    cout<<"L1"<