编程题实训-链表应用

第1关:基于链表的两个一元多项式的基本运算

任务描述

本关任务:给定两个一元多项式A(x)与B(x),利用链表表示A(x)与B(x),实现A(x)与B(x)的加法、减法、乘法和求导运算。

编程要求

输入

输入多组数据,总计n*( a+b+2)+1行。其中,第一行整数n代表总计有n组数据,之后依次输入n组数据。每组数据包括a+b+2行,其中第一行是两个整数a和b,分别代表A(x)与B(x)的项数。之后紧跟a行,每行两个整数a1和a2,分别代表A(x)每项的系数和指数,再之后紧跟b行,每行两个整数b1和b2,分别代表B(x)每项的系数和指数,每组数据最后一行为一个字符(+、-、*、'),分别代表多项式的加法、减法、乘法和求导运算。所有数据的绝对值小于100,指数大于等于0。

输出

对于每组数据输出一行,按照多项式次数从大到小排列,参考格式:5x^17+22x^7+11x^1+7。

#include 
#include 
using namespace std;
typedef struct  LNode{
	int coe;
	int exp;
	struct LNode *next;
}LNode,*LinkList;
void CreatePolynomial(LinkList &L,int n){
	L = new LNode;
	L->next = NULL;
	for(int i=0;i>p->coe>>p->exp;
		LinkList pre =L,cur = L->next;
		while(cur&&p->expexp){
			pre = cur;
			cur = cur->next;
		}
		p->next = cur;
		pre->next=p;
	}
}
void OutputPolynomial(LinkList L)
{//输出多项式
	if(!L||!L->next) cout<<0;
	LinkList p=L->next;     //p是多项式链表的工作指针,初始化为首元结点
	while(p)
	{
		if(p==L->next)     //p指向首元结点时,根据指数的情况输出多项式
        {
			if (p->exp!=0)
				cout<coe<<"x^"<exp;
			else
				cout<coe;
		}
		else      //p指向其他结点时,根据系数的正负和指数的情况输出多项式
        {
			if(p->coe>0) cout<<"+";
			if(p->exp!=0)
				cout<coe<<"x^"<exp;
			else
				cout<coe;
		}
		p=p->next;
	}
	cout<next;
	LinkList pb = LB->next;
	LinkList LC;
	CreatePolynomial(LC,0);
	LinkList pc = LC;
	while(pa&&pb){
		if(pa->exp == pb->exp){
			int sum = pa->coe + pb->coe;
			if(sum){
				pa->coe = sum;
				pc->next = pa;
				pc = pa;
				pa = pa->next;
				pb = pb->next;
			}else{
				pa = pa->next;
				pb = pb->next;
			}
		}else if(pa->exp>pb->exp){
			pc->next = pa;
			pc = pa;
			pa = pa->next;
		}else{
			pc->next = pb;
			pc = pb;
			pb = pb->next;
		}
	}
	pc->next = pa?pa:pb;
	return LC;
}


void Minus(LinkList LA,LinkList LB){
	LinkList p = LB->next;
	while(p){
		p->coe*= -1;
		p = p->next;
	}
	OutputPolynomial(Add(LA,LB));
}

LinkList Mul(LinkList LA,LinkList LB){
	LinkList pa = LA->next;
	LinkList pb = LB->next;
	LinkList LC;
	CreatePolynomial(LC,0);
	LinkList temp;
	CreatePolynomial(temp,0);
	while(pa){
		while(pb){
			LinkList p = new LNode;
			p->next = NULL;
			p->coe = pa->coe*pb->coe;
			p->exp = pa->exp + pb->exp;
			temp->next = p;
			LC = Add(LC,temp);
			pb = pb->next;  
		}
		pb = LB->next;
		pa = pa->next;
	}
	OutputPolynomial(LC);
	
}

void Diff(LinkList L)
{//多项式的求导运算
	LinkList p=L->next;  //p是链表L的工作指针,初始化为首元结点
	LinkList r=NULL;  //r是删除操作的辅助指针
	while(p)
	{
		p->coe*=p->exp;
		p->exp--;
		if(p->exp<0)  //所有数据的指数大于等于0
        {
			r=p;
			p=p->next;
			delete r;
		}
		else
		{
			p=p->next;
		}
	}
	OutputPolynomial(L);
}

void Opt(LinkList &LA,LinkList &LB,string s)
{//依据字符选择多项式的加法、减法、乘法和求导运算
    if(s=="+") OutputPolynomial(Add(LA, LB));
    if(s=="-") Minus(LA, LB);
    if(s=="*") Mul(LA, LB);
    if(s=="'")
    {
        Diff(LA);
        Diff(LB);
    }
}


int main(){
	int n;
	cin>>n;
	while(n--){
		int a,b;
		cin>>a>>b;
		LinkList LA,LB;
		CreatePolynomial(LA,a);
		CreatePolynomial(LB,b);
		string s;
		cin>>s;
		Opt(LA,LB,s);
	}
	return 0;
}

第2关:基于链表的两个递增有序序列的合并

任务描述

本关任务:给定两个递增的整数序列A和B,利用链表表示序列A和B,将A和B合并为一个递增的有序序列C,序列C不允许有重复的数据。要求空间复杂度为O(1)。

编程要求

输入

多组数据,每组数据有三行,第一行为序列A和B的长度n和m,第二行为序列A的n个元素,第三行为序列B的m个元素(元素之间用空格分隔)。n=0且m=0时输入结束。

输出

对于每组数据输出一行,为合并后的序列,每个数据之间用空格分隔。

#include 
using namespace std;
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;
void CreateList_R(LinkList &L,int n)
{//后插法创建单链表
    L=new LNode;
    L->next=NULL;
    LinkList r=L;
    for(int i=0;i>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void PrintList(LinkList &L)
{//打印依次输出链表中的数据
    L=L->next;
    while(L){
        if(L->next!=NULL) cout<data<<" ";
        else cout<data;
        L=L->next;
    }
    cout<next;
    pb=LB->next;
    pc=LC=LA;
    while (pa&&pb)
    {
        if (pa->datadata)
        {
            pc->next=pa;
            pc=pa;
            pa=pa->next;
        }
        else if (pa->data>pb->data)
        {
            pc->next=pb;
            pc=pb;
            pb=pb->next;
        }
        else 
        {
            pc->next=pa;  //删掉一样的
            pc=pa;
            pa=pa->next;
            q=pb->next;
            delete pb;
            pb=q;
        }
    }
    pc->next=pa?pa:pb;  //如果一个序列比完,结束循环,剩余的直接插在链表后面
    delete LB;


    /**************end************/
}
int main()
{
    int n,m;
    while(cin>>n>>m)
    {
        if(n==0&&m==0) break;
        LinkList LA,LB;
        CreateList_R(LA,n);
        CreateList_R(LB,m);
        MergeList(LA,LB);
        PrintList(LA);
    }
    return 0;
}

第3关:基于链表的两个非递减有序序列的合并

编程要求

输入

多组数据,每组数据有三行,第一行为序列A和B的长度n和m,第二行为序列A的n个元素,第三行为序列B的m个元素(元素之间用空格分隔)。n=0且m=0时输入结束。

输出

对于每组数据输出一行,为合并后的序列,每个数据之间用空格分隔。

//要结合上下文,本题与上题思路相似,但注意主函数中PrintList(LC);

#include 
using namespace std;
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;
void CreateList_R(LinkList &L,int n)
{//后插法创建单链表
    L=new LNode;
    L->next=NULL;
    LinkList r=L;
    for(int i=0;i>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void PrintList(LinkList &L)
{//打印依次输出链表中的数据
    L=L->next;
    while(L){
        if(L->next!=NULL) cout<data<<" ";
        else cout<data;
        L=L->next;
    }
    cout<next;
pb=LB->next;
LC=pc=LA;
LC->next=NULL;
while (pa||pb)
{
    if (!pa)//LA表为空,用q指向pb,pb指针后移
    {
        q=pb;
        pb=pb->next;
    }
    else if (!pb)//LB表为空,用q指向pa,pa指针后移
    {
        q=pa;
        pa=pa->next;
    }
    else if (pa->data<=pb->data)
    {
        q=pa;
        pa=pa->next;
    }
    else 
    {
        q=pb;
        pb=pb->next;
    }
    q->next=LC->next;
    LC->next=q;//将q指向的节点插在LC表的表头节点之后
}
delete LB;



    /**************end************/
}
int main()
{
    int n,m;
    while(cin>>n>>m)
    {
        if(n==0&&m==0) break;
        LinkList LA,LB,LC;
        CreateList_R(LA,n);
        CreateList_R(LB,m);
        MergeList(LA,LB,LC);
        PrintList(LC);
    }
    return 0;
}

第4关:基于链表的两个集合的交集

任务描述

本关任务:给定两个递增的整数集合A和B,分别用链表表示集合A和B,求出A和B的交集,并存放在A中。要求空间复杂度为O(1)。

编程要求

输入

多组数据,每组数据有三行,第一行为序列A和B的长度n和m,第二行为序列A的n个元素,第三行为序列B的m个元素(元素之间用空格分隔)。n=0且m=0时输入结束。

输出

对于每组数据输出一行,为A和B的交集,每个数据之间用空格分隔。

#include 
using namespace std;
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;
void CreateList_R(LinkList &L,int n)
{//后插法创建单链表
    L=new LNode;
    L->next=NULL;
    LinkList r=L;
    for(int i=0;i>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void PrintList(LinkList &L)
{//打印依次输出链表中的数据
    L=L->next;
    while(L){
        if(L->next!=NULL) cout<data<<" ";
        else cout<data;
        L=L->next;
    }
    cout<next;
pb=LB->next; //pa 和 pb 分别是链表 La 和 Lb 的工作指针 , 初始化为相应链表的第一个结点
	LC=pc=LA; // 用 La 的头结点作为 Lc 的头结点
	while(pa&&pb) 
	{ 
		  if (pa->data==pb->data)//交集并入结果表中。
	 	  { pc->next=pa;
            pc=pa;pa=pa->next; 
	        u=pb;pb=pb->next; 
            delete u;
          } 
		else if(pa->datadata) 
		{
        u=pa;
        pa=pa->next; 
        delete u;
        } 
		else 
		{
        u=pb; 
        pb=pb->next;
        delete u;
        } 
	}
	while(pa)
    {
    u=pa; 
    pa=pa->next; 
    delete u;
    } //释放结点空间
	 while(pb) 
     {
     u=pb; 
     pb=pb->next; 
     delete u ;
     } //释放结点空间
	pc->next=NULL;//置链表尾标记。
	delete LB; // 释放 Lb 的头结点


    /**************end************/
}
int main()
{
    int n,m;
    while(cin>>n>>m)
    {
        if(n==0&&m==0) break;
        LinkList LA,LB;
        CreateList_R(LA,n);
        CreateList_R(LB,m);
        Intersection(LA,LB);
        PrintList(LA);
    }
    return 0;
}

第5关:基于链表的两个集合的差集

任务描述

本关任务:给定两个递增的整数集合,分别用链表A和B表示,求出A和B的差集(即仅由在A中出现而不在B中出现的元素所构成的集合),并以同样的形式存储,同时返回该集合的元素个数。要求空间复杂度为O(1)。

编程要求

输入

多组数据,每组数据有三行,第一行为序列A和B的长度n和m,第二行为序列A的n个元素,第三行为序列B的m个元素(元素之间用空格分隔)。n=0且m=0时输入结束。

输出

对于每组数据输出两行,第一行是A和B的差集,第二行为差集中的元素个数,每个数据之间用空格分隔。

#include 
using namespace std;
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;
void CreateList_R(LinkList &L,int n)
{//后插法创建单链表
    L=new LNode;
    L->next=NULL;
    LinkList r=L;
    for(int i=0;i>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void PrintList(LinkList &L)
{//依次输出链表中的数据和该集合的元素个数
    L=L->next;
    int s=0;
    while(L)
    {
        if(L->next!=NULL) cout<data<<" ";
        else cout<data;
        L=L->next;
        s++;
    }
    cout<next;
pb=LB->next;
pre=LA;//pre为LA中pa所指结点的前驱结点的指针
while (pa&&pb)
{
    if (pa->datadata)
    {
        pre=pa;
        pa=pa->next;
       
    }
    else if (pa->data>pb->data)
    {
        pb=pb->next;

    }
    else 
    {
        pre->next=pa->next;//处理A,B中元素相同的结点,应删除
        u=pa;
        pa=pa->next;
        delete u;
    }
}



   
    /**************end************/
}
int main()
{
    int n,m;
    while(cin>>n>>m)
    {
        if(n==0&&m==0) break;
        LinkList LA,LB;
        CreateList_R(LA,n);
        CreateList_R(LB,m);
        Difference(LA,LB);
        PrintList(LA);
    }
    return 0;
}

第6关:链表的分解

任务描述

本关任务:利用单链表A表示一个非零整数序列,把A分解为两个具有相同结构的链表B和C,其中B表的结点为A表中值小于零的结点,而C表的结点为A表中值大于零的结点。要求空间复杂度为O(1),链表B和C均利用链表A的结点空间。

编程要求

输入

多组数据,每组数据有两行,第一行为链表A的长度n,第二行为链表A的n个元素(元素之间用空格分隔)。当n=0时输入结束。

输出

对于每组数据分别输出两行,分别对应链表B和C的元素,每个数据之间用空格分隔。

#include 
using namespace std;
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;
void CreateList_R(LinkList &L,int n)
{//后插法创建单链表
    L=new LNode;
    L->next=NULL;
    LinkList r=L;
    for(int i=0;i>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void PrintList(LinkList &L)
{//打印依次输出链表中的数据
    L=L->next;
    while(L){
        if(L->next!=NULL) cout<data<<" ";
        else cout<data;
        L=L->next;
    }
    cout<next=NULL;
  LC=new LNode;
  LC->next=NULL;
  LinkList pa=LA->next,pb=LB,pc=LC,q;//pa,pb和pc分别是LA,LB和LC的工作指针,q暂存pa的后继
  while (pa!=NULL)
  {
      q=pa->next;
      if (pa->data<0)//将小于0的结点链入LB表,尾插法
      { 
        pb->next=pa;
        pb=pa;
      }
      else
      {
        pc->next=pa;
        pc=pa;
      }
      pa=q;
  }
  pb->next=NULL;
  pc->next=NULL;
  


  
    /**************end************/
}
int main()
{
    int n;
    while(cin>>n)
    {
        if(n==0) break;
        LinkList LA,LB,LC;
        CreateList_R(LA,n);
        Decompose(LA,LB,LC);
        PrintList(LB);
        PrintList(LC);
    }
    return 0;
}

第7关:查找链表中的最大值 

任务描述

本关任务:利用单链表表示一个整数序列,通过一趟遍历在单链表中确定值最大的结点。

编程要求

输入

多组数据,每组数据有两行,第一行为链表的长度n,第二行为链表的n个元素(元素之间用空格分隔)。当n=0时输入结束。

输出

对于每组数据分别输出一行,输出每个链表的最大值。

#include 
using namespace std;

typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;

void CreateList_R(LinkList &L,int n)
{
    L->next=NULL;
    LinkList r=new LNode;
    r=L;
    for(int i=0;i>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}

int MaxData(LinkList L)
{//确定单链表中值最大的结点
/**************begin************/
  LinkList p ,MaxData;
  if (L->next==NULL)
  return NULL;
   MaxData=L->next;
   p=L->next->next;
  while (p!=NULL)
  {
      if (p->data > MaxData->data)// 如果 p 的值大于 pmax 的值,则重新赋值
      {
        MaxData=p;
      }
      p=p->next;
  } 
return MaxData->data;



  
    /**************end************/
}

int main()
{
    int n;
    while(cin>>n)
    {
        if(n==0) break;
        LinkList L=new LNode;
        CreateList_R(L,n);
        cout<

第8关:链表的逆转 

任务描述

本关任务:利用单链表表示一个整数序列,通过一趟遍历,将单链表中所有结点的链接方向逆转。要求空间复杂度为O(1)。

编程要求

输入

多组数据,每组数据有两行,第一行为链表的长度n,第二行为链表的n个元素(元素之间用空格分隔)。当n=0时输入结束。

输出

对于每组数据分别输出一行,逆序输出链表中的元素,元素之间用空格分隔。

#include 
using namespace std;

typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;

void CreateList_R(LinkList &L,int n)
{
    L->next=NULL;
    LinkList r=new LNode;
    r=L;
    for(int i=0;i>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}

void Inverse(LinkList &L)
{//逆置带头结点的单链表L
/**************begin************/
LinkList p,q;
p=L->next;
L->next=NULL;
while (p)
{
    q=p->next;
    p->next=L->next;
    L->next=p;
    p=q;
}




    /**************end************/
}

void PrintList(LinkList &L)
{
    L=L->next;
    while(L){
        if(L->next!=NULL) cout<data<<" ";
        else cout<data;
        L=L->next;
    }
    cout<>n)
    {
        if(n==0) break;
        LinkList L=new LNode;
        CreateList_R(L,n);
        Inverse(L);
        PrintList(L);
    }
    return 0;
}

第9关:删除链表中满足区间值的结点 

任务描述

本关任务:利用单链表表示一个递增的整数序列,删除链表中值大于等于mink且小于等于maxk的所有元素(mink和maxk是给定的两个参数,其值可以和表中的元素相同,也可以不同)。

编程要求

输入

多组数据,每组数据有两行,第一行为链表的长度n,第二行为链表的n个元素(元素之间用空格分隔),第三行为给定的mink和maxk(用空格分隔)。当n=0时输入结束。

输出

对于每组数据分别输出一行,依次输出删除元素后的链表元素,元素之间用空格分隔。

#include 
using namespace std;
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;
void CreateList_R(LinkList &L,int n)
{//后插法创建单链表
    L=new LNode;
    L->next=NULL;
    LinkList r=L;
    for(int i=0;i>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void PrintList(LinkList &L)
{//打印依次输出链表中的数据
    L=L->next;
    while(L){
        if(L->next!=NULL) cout<data<<" ";
        else cout<data;
        L=L->next;
    }
    cout<next;
while (p&&p->datanext;//查找第一个值>mink的结点
}
 
    while (p&&p->data<=maxk)
    {
        p=p->next;
    }
    
    q=pre->next;
    pre->next=p;
    while (q!=p)
    {
        s=q->next;
        delete q;
        q=s;
    }



    /**************end************/
}
int main()
{
    int n;
    while(cin>>n)
    {
        if(n==0) break;
        LinkList L;
        CreateList_R(L,n);
        int mink,maxk;
        cin>>mink>>maxk;
        DeleteMinMax(L,mink,maxk);
        PrintList(L);
    }
    return 0;
}

第10关:双向循环链表中结点的交换 

任务描述

本关任务:利用双向循环链表表示一个整数序列,指定一个结点位置用p指向该结点,交换p所指向的结点及其前驱结点的顺序。

编程要求

输入

多组数据,每组数据有三行,第一行为链表的长度n,第二行为链表的n个元素(元素之间用空格分隔),第三行为p所指向的结点位置。当n=0时输入结束。

输出

对于每组数据分别输出一行,依次输出交换结点顺序后的链表元素,元素之间用空格分隔。

#include
using namespace std;
typedef struct DuLNode
{
	int data;
	struct DuLNode *next;
	struct DuLNode *prior;
}DuLNode,*DuLinkList;
void CreateList(DuLinkList &L,int n)
{//建立双向循环链表

    L=new DuLNode;    //初始化链表L的头结点
	L->prior=L;
	L->next=L;
	DuLinkList r=L;     //工作指针r初始化指向头结点
	while(n--)
	{
		DuLinkList p=new DuLNode;
		cin>>p->data;
		p->next=r->next;
		r->next=p;
		p->prior=r;
		p->next->prior=p;
		r=p;
	}
}
void Exchange(DuLinkList &L,int loc)
{//双向循环链表中结点的交换
/**************begin************/
   DuLinkList p,q;
int j;
p=L->next;
j=1;
while (p&&jnext;
    j++;
}
q=p->prior;//定位前一个结点
p->prior=p->prior->prior;//更改p的前驱
q->prior->next=p;//更改q的前驱的后继指向p
q->next=p->next;
p->next=q;
q->prior=p;

    /**************end************/
}
void PrintList(DuLinkList &L)
{//依次输出链表中的数据
    DuLinkList p=L->next;
	while(p->next&&p->next!=L)
	{
		cout<data<<" ";
		p=p->next;
	}
	cout<data<>n)
	{
	 	if(n==0) break;
	 	DuLinkList L;
	 	CreateList(L,n);
	 	int loc;
		cin>>loc;
		if(n==1)          //链表仅有一个元素时输出其自身
		{
			cout<next->data<

第11关:查找链表中倒数第k个结点 

任务描述

本关任务:利用单链表表示一个整数序列,请实现一个时间复杂度为O(n)、空间复杂度为O(1)的算法,通过一趟遍历在单链表中确定倒数第k个结点。

编程要求

输入

多组数据,每组数据有三行,第一行为链表的长度n,第二行为链表的n个元素(元素之间用空格分隔),第三行为k。当n=0时输入结束。

输出

对于每组数据分别输出一行,输出每个链表的倒数第k个结点对应的数值。

#include 
using namespace std;
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;
void CreateList_R(LinkList &L,int n)
{//后插法创建单链表
    L=new LNode;
    L->next=NULL;
    LinkList r=L;
    for(int i=0;i>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void Search_k(LinkList L,int k)
{
    /**************begin************/
LinkList p=L->next,q=L->next;
int n=0;
while (p!=NULL)//p先走k步,然后和q一起走,p到达尾部时,q所指的刚好就是倒数第k的结点
{
    if (nnext;
    n++;
    }
    else 
    {
        p=p->next;
        q=q->next;
    }
}
cout<data<>n)
    {
        if(n==0) break;
        LinkList L;
        CreateList_R(L,n);
        int k;
        cin>>k;
        Search_k(L,k);
    }
    return 0;
}

第12关:删除链表中绝对值相等的结点 

任务描述

本关任务:利用单链表表示一个整数序列,实现一个时间复杂度为O(n)的算法,对于链表中绝对值相等的结点,仅保留第一次出现的结点而删除其余绝对值相等的结点。

例如,若给定的单链表HEAD如下:

编程题实训-链表应用_第1张图片

删除后的单链表HEAD为:

编程题实训-链表应用_第2张图片

编程要求

输入

多组数据,每组数据有两行,第一行为链表的长度n,第二行为链表的n个元素(元素之间用空格分隔)。当n=0时输入结束。

输出

对于每组数据分别输出一行,依次输出删除结点后的链表元素,元素之间用空格分隔。

#include 
using namespace std;
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;
void CreateList_R(LinkList &L,int n)
{//后插法创建单链表
    L=new LNode;
    L->next=NULL;
    LinkList r=L;
    for(int i=0;i>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void PrintList(LinkList &L)
{//打印依次输出链表中的数据
    L=L->next;
    while(L){
        if(L->next!=NULL) cout<data<<" ";
        else cout<data;
        L=L->next;
    }
    cout<0?x:-x;
}
void DeleteEqualNode(LinkList &L,int n)
{//删除链表中绝对值相等的结点
/**************begin************/
    LinkList p,r;
p=L;
int a[100],m;
for (int i=0;i<100;i++)
{
    a[i]=0;
}
while (p->next!=NULL)
{
    if (p->next->data>=0)
        m=p->next->data;//看结点的绝对值在数组的位序中是否是1
    else 
    m=-(p->next->data);
    if (a[m]==0)
    {
        a[m]=1;
        p=p->next;
    }
    else 
    {
        r=p->next;
        p->next=r->next;
        delete r;
    }
}





    /**************end************/
}
int main()
{
    int n;
    while(cin>>n)
    {
        if(n==0) break;
        LinkList L;
        CreateList_R(L,n);
        DeleteEqualNode(L,n);
        PrintList(L);
    }
    return 0;
}

第13关:查找两个单词链表共同后缀的起始结点 

任务描述

本关任务:假定采用带头结点的单链表保存单词,当两个单词有相同的后缀时,则可共享相同的后缀空间。 例如,“loading”和“being”的存储映像如下图所示:

编程题实训-链表应用_第3张图片

设str1和str2分别指向两个单词所在单链表的头结点,请实现一个时间上尽可能高效的算法,找出由str1和str2所指的两个链表共同后缀的起始位置的结点,输出该结点对应的字符(如图中的字符i)。

编程要求

输入

多组数据,每组数据有三行,第一行为链表str1和str2的长度n和m,第二行为链表str1的n个元素,第三行为链表str2的m个元素(元素之间用空格分隔)。n=0且m=0时输入结束。

输出

对于每组数据输出一行,为共同后缀的起始位置结点对应的字符。

#include 
using namespace std;
typedef struct LNode
{
    char data;
    struct LNode *next;
}LNode,*LinkList;
void CreateList_R(LinkList &L,int n)
{//后插法创建单链表
    L=new LNode;
    L->next=NULL;
    LinkList r=L;
    for(int i=0;i>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void FindSuffix(LinkList str1, LinkList str2,int n,int m)
{//查找两个单词链表共同后缀的起始结点

/**************begin************/
 
LinkList longstr,shortstr;
 int k;
 if (n>m)
 {
     longstr=str1->next;
     shortstr=str2->next;
     k=n-m;
 }
else 
{
    longstr=str2->next;
    shortstr=str1->next;
    k=m-n;
}
while (k--)
longstr=longstr->next;
LinkList t=longstr;
int flag=0;
while (longstr)
{
    if (longstr->data==shortstr->data)
    {
        if (flag==0)
        {
            t=longstr;
            flag=1;
        }
    }
    else 
    {
        flag=0;
    }
    longstr=longstr->next;
    shortstr=shortstr->next;
}
cout<data<>n>>m)
    {
        if(n==0&&m==0) break;
        LinkList str1,str2,p;
        CreateList_R(str1,n);
        CreateList_R(str2,m);
        FindSuffix(str1,str2,n,m);
    }
    return 0;
}

第14关:猴子选大王问题 

任务描述

本关任务:一堆猴子都有编号,编号是1,2,3 ...m,这群猴子(m个)按照1~m的顺序围坐一圈,从第1开始数,每数到第n个,该猴子就要离开此圈,这样依次下来,直到圈中只剩下最后一只猴子,则该猴子为大王。利用单向循环链表模拟此过程,依次输出出圈的猴子编号。

编程要求

输入

多组数据,每组数据占一行,包括两个数据m和n。m代表猴子个数,n代表步数,m=0且n=0时输入结束。

输出

依次输出出圈的猴子编号,编号之间用空格隔开。

#include 
using namespace std;
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;
void CreateCirList(LinkList &L,int m)
{//后插法创建单向循环链表
    L=new LNode;
    L->next=NULL;
    L->data=1;
    LinkList r=L;
    for(int i=2;i<=m;i++)
    {
        LinkList p=new LNode;
        p->data=i;
        p->next=NULL;
        r->next=p;
        r=p;
    }
    r->next=L;                                   //尾结点的指针指向首元结点,单向循环链表建成
    L=r;                                          //L需要指向尾结点,以防n=1时第一个需要删除的是首元结点,不易得到前驱结点
}
void MonkeyKing(LinkList &L,int n)
{//猴子选大王(约瑟夫问题)
/**************begin************/
   // int answer[100];
 
LinkList tail,head,p,q;
head=L;
tail=head;
p=head->next;
q=tail;//p在最前面时,最后一个节点是他的前继结点
int i=1;
while (p!=q)
{
    if (i==n)
    {
        q->next=p->next;
        printf ("%d ",p->data);
        delete p;
        p=q->next;
        i=1;
    }
    else 
    {//p,q各自向后移动一个节点,其中q总在p的前面
    q=p;
    p=p->next;
    i++;
    }
   
}
 printf ("%d",q->data);
 printf ("\n");






   
    /**************end************/
}
int main()
{
    int m,n;
    while(cin>>m>>n)
    {
        if(n==0&&m==0) break;
        LinkList L;
        CreateCirList(L,m);
        MonkeyKing(L,n);
    }
    return 0;
}

第15关:奇偶链表的分割 

任务描述

本关任务:给定一个单链表,把所有的奇数结点和偶数结点分别排在一起,重新链成一个新链表。请注意,这里的奇数结点和偶数结点指的是结点编号的奇偶性,而不是结点的值的奇偶性。

要求:空间复杂度应为 O(1),时间复杂度应为 O(n),n 为链表结点总数。

编程要求

输入

多组数据,每组数据有两行,第一行为链表的长度n,第二行为链表的n个元素(元素之间用空格分隔)。当n=0时输入结束。

输出

奇数结点和偶数结点分割后重新链成的新链表。

#include
using namespace std;
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;
void CreateList_R(LinkList &L,int n)
{//后插法创建单链表
    L=new LNode;
    L->next=NULL;
    LinkList r=L;
    for(int i=0;i>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void Decollate(LinkList L,LinkList L1)
{//奇偶链表的分割
/**************begin************/
  LinkList p=L->next;//初始化p指向L的首元节点
  LinkList q=L;//初始化q指向L的头节点
  LinkList p1=L1;//初始化p1指向新链表L1的头结点
  int num=1;
  while (p)
  {
      if (num%2!=0)
      {
          p1->next=p;
          p1=p1->next;
          q->next=p->next;
          p->next=NULL;
          p=q->next;
      }
      else 
      {
          q=q->next;
          p=p->next;
      }
      num++;//结点序号加1;
  }
  p1->next=L->next;//将剩余链表部分链入新链表的表尾
  delete L;//删除原链表的头结点





  
    /**************end************/
}
void PrintList(LinkList &L)
{//依次输出链表中的数据
    LinkList p=L->next;
    while(p)
    {
        if(p->next!=NULL) cout<data<<" ";
        else cout<data;
        p=p->next;
    }
    cout<>n)
	{
		if(n==0) break;
		LinkList L=new LNode;
        CreateList_R(L,n);
        LinkList L1=new LNode;    //申请新链表L1
        L1->next=NULL;
        Decollate(L,L1);      //奇偶链表的分割
        PrintList(L1);
	}
	return 0;
}

你可能感兴趣的:(数据结构--头歌,链表,数据结构,算法)