编程题实训-链表应用

已于 2024-03-27 12:23:34 修改
阅读量209 收藏 1
点赞数 2
文章标签： 链表 数据结构 算法
于 2024-03-27 12:22:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77276656/article/details/137073415
版权

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

#include <iostream>
#include <string>
using namespace std;
typedef struct LNode
{
    int coe;    //系数coe
    int exp;    //指数exp
    struct LNode *next;
}LNode,*LinkList;
void CreatePolynomial(LinkList &L,int n)
{//按指数exp从大到小存多项式
    L=new LNode;
    L->next=NULL;
    for(int i=0;i<n;i++)
    {
        LinkList p=new LNode;
        cin>>p->coe>>p->exp;
        LinkList pre=L,cur=L->next;      //pre和cur是多项式链表的工作指针，分别初始化为头结点和首元结点
		while(cur&&p->exp<cur->exp)    //若待插入项的指数小于当前结点的指数，指针pre指向当前结点，当前结点的指针cur后移
		{
			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<<p->coe<<"x^"<<p->exp;
			else
				cout<<p->coe;
		}
		else      //p指向其他结点时，根据系数的正负和指数的情况输出多项式
        {
			if(p->coe>0) cout<<"+";
			if(p->exp!=0)
				cout<<p->coe<<"x^"<<p->exp;
			else
				cout<<p->coe;
		}
		p=p->next;
	}
	cout<<endl;
}
LinkList Add(LinkList LA,LinkList LB)
{//多项式的加法运算
/**************begin************/
	LinkList LC,pa,pb,pc;
    pa=LA->next;
    pb=LB->next;
    CreatePolynomial(LC,0);
    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;


    /**************end************/
}
void Minus(LinkList LA,LinkList LB)
{//多项式的减法
/**************begin************/
	LinkList p=LB->next;
     while(p)
     {
         p->coe*=-1;
         p=p->next;
     }
     OutputPolynomial(Add(LA, LB));

    /**************end************/
}
void Mul(LinkList LA,LinkList LB)
{//多项式的乘法
/**************begin************/
    LinkList LC;
    LinkList pa=LA->next;
    LinkList pb=LB->next;
 
    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);

    /**************end************/
}
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;    //总计有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关 基于链表的两个递增有序序列的合并

#include <iostream>
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<n;i++)
    {
        LinkList p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void PrintList(LinkList &L)
{//打印依次输出链表中的数据
    L=L->next;
    while(L){
        if(L->next!=NULL) cout<<L->data<<" ";
        else cout<<L->data;
        L=L->next;
    }
    cout<<endl;
}
void MergeList(LinkList &LA,LinkList &LB)
{//求基于链表的两个递增有序序列的合并
/**************begin************/
    LinkList r1,r2,r3;
    r1=LA->next;
    r2=LB->next;
    r3=LA;
    while (r1!=NULL && r2!=NULL)
    {
        if (r1->data<r2->data)
        {
            r3->next=r1;
            r3=r1;
            r1=r1->next;
        }
        else if (r1->data==r2->data)
        {
            r3->next=r1;
            r3=r1;
            r1=r1->next;
            r2=r2->next;
        }
        else
        {
            r3->next=r2;
            r3=r2;
            r2=r2->next;
        }        
    }
    
  r3->next=r1?r1:r2;
    /**************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关 基于链表的两个非递减有序序列的合并

#include <iostream>
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<n;i++)
    {
        LinkList p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void PrintList(LinkList &L)
{//打印依次输出链表中的数据
    L=L->next;
    while(L){
        if(L->next!=NULL) cout<<L->data<<" ";
        else cout<<L->data;
        L=L->next;
    }
    cout<<endl;
}
void MergeList(LinkList &LA,LinkList &LB,LinkList &LC)
{//求基于链表的两个非递减有序序列的合并
/**************begin************/
    LinkList pa,pb,pc,q;
    pa=LA->next; 
    pb=LB->next; 
    LC =new LNode;
    pc=LC; 
    LC->next=NULL;
    while(pa||pb ){
        if(!pa) { 
	    q=pb;      
	    pb=pb->next;
	    }               
    else if(!pb)  {
	    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;   
}
    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关 基于链表的两个集合的交集

#include <iostream>
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<n;i++)
    {
        LinkList p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void PrintList(LinkList &L)
{//打印依次输出链表中的数据
    L=L->next;
    while(L){
        if(L->next!=NULL) cout<<L->data<<" ";
        else cout<<L->data;
        L=L->next;
    }
    cout<<endl;
}
void Intersection(LinkList &LA,LinkList &LB)
{//求基于链表的两个集合的交集
/**************begin************/
    LinkList pc=LA,pa=LA->next,pb=LB->next;
	while(pa&&pb)
	{
		if(pa->data==pb->data)
		{
			pc->next=pa; 
			pc=pa;
			
			if(pb->next==NULL||pa->next==NULL)
			{
				
				pc->next=NULL;
				break; 
			} 	
			pa=pa->next;
			pb=pb->next;
		}
		else if(pa->data > pb->data) pb=pb->next;
				else if(pa->data < pb->data) pa=pa->next;
		
	}
	
	pc->next=NULL; 
	delete LB;
	return;
    /**************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关 基于链表的两个集合的差集

#include <iostream>
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<n;i++)
    {
        LinkList p=new LNode;
        cin>>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<<L->data<<" ";
        else cout<<L->data;
        L=L->next;
        s++;
    }
    cout<<endl<<s<<endl;
}
void Difference(LinkList &LA,LinkList &LB)
{//求基于链表的两个集合的差集
/**************begin************/
    LinkList pa, pb, p;
    pa = LA->next;
    pb = LB->next;
    p = LA;
    while ( pa&&pb ) {
        if ( pa->data == pb->data ) {
            pa = pa->next;
            pb = pb->next;
        } else if ( pa->data > pb->data ) {
            pb = pb->next;
        } else {
            p->next = pa;
            pa = pa->next;
            p = p->next;
        }
        if ( pb==NULL ) {
            p->next = pa;
        }
    }
   
    /**************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关 链表的分解

#include <iostream>
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<n;i++)
    {
        LinkList p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void PrintList(LinkList &L)
{//打印依次输出链表中的数据
    L=L->next;
    while(L){
        if(L->next!=NULL) cout<<L->data<<" ";
        else cout<<L->data;
        L=L->next;
    }
    cout<<endl;
}
void Decompose(LinkList &LA,LinkList &LB,LinkList &LC)
{//链表的分解
/**************begin************/
    LB=new LNode;LB->next=NULL;
    LC=new LNode;LC->next=NULL;
    LinkList pa,pb,pc;
    pa=LA->next;
    pb=LB;
    pc=LC;
    while(pa){
        if(pa->data>0){
            pc->next=pa;
            pc=pc->next;
            pa=pa->next;
            pc->next=NULL;
        }
        else{
            pb->next=pa;
            pb=pb->next;
            pa=pa->next;
            pb->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关 查找链表中的最大值

#include <iostream>
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<n;i++)
    {
        LinkList p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}

int MaxData(LinkList L)
{//确定单链表中值最大的结点
/**************begin************/
    LinkList max=new LNode,p;
	
	p=L->next;
	max->data=p->data;
	p=p->next;
	while(p)
	{
		if(p->data > max->data)
			max->data=p->data;
		p=p->next;
	}
	return max->data;
  
    /**************end************/
}

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

第8关 链表的逆转

#include <iostream>
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<n;i++)
    {
        LinkList p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}

void Inverse(LinkList &L)
{//逆置带头结点的单链表L
/**************begin************/
    if(L == NULL || L->next == NULL) return; 
    LinkList p = L->next, q; 
    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<<L->data<<" ";
        else cout<<L->data;
        L=L->next;
    }
    cout<<endl;
}

int main()
{
    int n;
    while(cin>>n)
    {
        if(n==0) break;
        LinkList L=new LNode;
        CreateList_R(L,n);
        Inverse(L);
        PrintList(L);
    }
    return 0;
}

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

#include <iostream>
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<n;i++)
    {
        LinkList p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void PrintList(LinkList &L)
{//打印依次输出链表中的数据
    L=L->next;
    while(L){
        if(L->next!=NULL) cout<<L->data<<" ";
        else cout<<L->data;
        L=L->next;
    }
    cout<<endl;
}
void DeleteMinMax(LinkList &L,int mink,int maxk)
{//删除链表中满足区间值的结点
/**************begin************/
    LinkList p=L->next,pre=L;
    while(p)
    {
        if(p->data>=mink && p->data <= maxk)
        {
            pre->next=p->next;
            p=p->next;
        }
        else
        {
            p=p->next;
            pre=pre->next;
        }
    }
    /**************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关 双向循环链表中结点的交换

#include<iostream>
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 = L;
    for (int i = 0; i < loc - 1; i ++) { 
        if(p!=NULL){
            p = p -> next;
        }
 
    }
    int temp = p->data;
    p -> data = p -> next -> data;
    p -> next -> data = temp;

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

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

#include <iostream>
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<n;i++)
    {
        LinkList p=new LNode;
        cin>>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 count=0;
    while(count<k) 
    {
        p=p->next;
        count++;
    }
    while(p)
    {
        p=p->next;
        q=q->next;
    }
    cout<<q->data<<endl;


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

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

#include <iostream>
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<n;i++)
    {
        LinkList p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void PrintList(LinkList &L)
{//打印依次输出链表中的数据
    L=L->next;
    while(L){
        if(L->next!=NULL) cout<<L->data<<" ";
        else cout<<L->data;
        L=L->next;
    }
    cout<<endl;
}
int Abs(int x)
{//绝对值函数
	return x>0?x:-x;
}
void DeleteEqualNode(LinkList &L,int n)
{//删除链表中绝对值相等的结点
/**************begin************/
    LinkList p=L->next,q=L;
    int arr[100];
    for(int i=0;i<=99;i++)
    {
        arr[i]=0;
    }

    while(p)
    {
        if(arr[Abs(p->data)]==0)
        {
            arr[Abs(p->data)]=1;
            p=p->next;
            q=q->next;
        }
        else
        {
            LinkList tem=p;
            q->next=p->next;
            p=p->next;
            delete tem;
        }
    }

    /**************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关 查找两个单词链表共同后缀的起始结点

#include <iostream>
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<n;i++)
    {
        LinkList p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void FindSuffix(LinkList str1, LinkList str2,int n,int m)
{//查找两个单词链表共同后缀的起始结点

/**************begin************/
    LinkList p,q;
    if(n>m) 
    {
        p=str1->next;
        q=str2->next;
    }
    else 
    {
        q=str1->next;
        p=str2->next;
    }
    int diff=n-m;
    if(diff<0) diff=diff*(-1);
    int count=0;
    while(count<diff)
    {
        p=p->next;
        count++;
    }
    while(p&&q)
    {
        if(p->data==q->data)
        {
            cout<<p->data<<endl;
            break;
        }
    p=p->next;
    q=q->next;
    }

 
   /**************end************/
}
int main()
{
    int n,m;
    while(cin>>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;
}

第15关奇偶链表的分割

#include<iostream>
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<n;i++)
    {
        LinkList p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void Decollate(LinkList L,LinkList L1)
{//奇偶链表的分割
/**************begin************/
    LinkList p=L->next;   
    LinkList q=L;          
    LinkList 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++;      
    }
    p1->next=L->next;     
    delete L; 
    /**************end************/
}
void PrintList(LinkList &L)
{//依次输出链表中的数据
    LinkList p=L->next;
    while(p)
    {
        if(p->next!=NULL) cout<<p->data<<" ";
        else cout<<p->data;
        p=p->next;
    }
    cout<<endl;
}
int main()
{
	int n;
	while(cin>>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;
}

luv.uv
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
课设：链表应用
weixin_46750633的博客
12-15 185
主要熟悉链表的创建、插入（头插和尾插）、删除。遍历操作 #include <iostream> #include<algorithm> #include<cstring> #include<cstdio> using namespace std; const int N=220; typedef struct node { int number; //编号 char name[40]; //姓名 char tel[40]
数据结构实训-学生分配问题.doc
11-29
"数据结构实训-学生分配问题" 本文档主要讲解了数据结构实训中的学生搭配问题，使用循环队列解决该问题。下面是相关的知识点： 1. 数据结构实训：数据结构实训是计算机科学中的一门重要课程，旨在教会学生如何使用...
数据结构：编程题实训-链表应用(转载)
Dr_icewine的博客
03-20 231
之后紧跟a行，每行两个整数a1和a2，分别代表A(x)每项的系数和指数，再之后紧跟b行，每行两个整数b1和b2，分别代表B(x)每项的系数和指数，每组数据最后一行为一个字符（+、-、*、'），分别代表多项式的加法、减法、乘法和求导运算。多组数据，每组数据有三行，第一行为序列A和B的长度n和m，第二行为序列A的n个元素，第三行为序列B的m个元素（元素之间用空格分隔）。多组数据，每组数据有三行，第一行为序列A和B的长度n和m，第二行为序列A的n个元素，第三行为序列B的m个元素（元素之间用空格分隔）。
编程题实训-栈
a61233的博客
11-04 4324
本关任务：输入一个中缀算术表达式，求解表达式的值。运算符包括+、-、*、/、(、)、=，参加运算的数为double类型且为正数。（要求：直接针对中缀算术表达式进行计算，不能转换为后缀或前缀表达式再进行计算，只考虑二元运算即可。）多组数据，每组数据一行，对应一个算术表达式，每个表达式均以“=”结尾。当表达式只有一个“=”时，输入结束。参加运算的数为double类型。对于每组数据输出一行，为表达式的运算结果。输出保留两位小数。 这个函数接收三个参数：一个名为的操作符栈，一个名为的
编程题实训-基于顺序表的图书信息管理（头歌）
a61233的博客
10-09 8789
第1关：基于顺序存储结构的图书信息表的创建和输出。
数据结构专题实验1- 链表的应用（C语言实现）
qq_60545192的博客
01-30 646
软件工程专业本科，数据结构学期实训第一期，此系列旨在分享和讲解本人写过的项目代码，方便各位朋友们学习，以求共同进步。
HPU--数据结构编程实训--树和二叉树
weixin_46529556的博客
11-18 1874
此代码只是头文件不是源文件，代码可直接当作头文件使用，仅提供相关算法的设计参考，没有主函数等。 下面是实训的第二题到第十二题，第一题我目前还没有写出来，如有小伙伴写出来了可以私信我共同讨论哟。
头歌数据结构——链表及其应用
weixin_62440328的博客
10-29 4695
【代码】头歌数据结构——链表及其应用。
头歌C语言数据结构课程实验（链表及其应用）
zzj的博客
05-12 1029
定义如下：//数据元素的类型为整数//数据域//指针域// LinkList为指向结构体LNode的指针类型。
C语言程序设计实训-基于链表、数组的学生管理系统
06-23
C语言程序设计实训-基于链表、数组的学生管理系统
C语言实训--超市商品管理.doc
05-17
C语言实训--超市商品管理系统 本文旨在介绍一个使用C语言开发的超市商品管理系统。该系统具有五个模块，分别是商品详细信息、商品买卖信息、库存商品登陆、库存商品删除和库存商品修改。该系统使用链表、数组和...
数据结构学习--线性表及其应用--链表
06-25
本程序的主要目的在于帮助同学熟练掌握线性表的基本操作在链式存储结构上的...通过本实验， 对链表基本操作及其组合应用的演练，加深对链表存储方法及其基本操作的理解，为以后进 一步学习更复杂的数据结构打下基础。
scratch2源码第24讲-链表应用2取随机数
05-30
scratch2源码第24讲-链表应用2取随机数提取方式是百度网盘分享地址
C++:十大排序
最新发布
2301_80418172的博客
06-12 990
十大排序CPP
ACM算法学习路线、清单
qq_45477639的博客
06-10 1921
算法与数据结构学习路线
C语言刷题（函数）
2303_82176667的博客
06-09 798
一个数如果恰好等于它的所有因子(不包括它本身)之和，这个数就称为“完数”。
C数据结构：排序
2301_80655639的博客
06-12 994
若按照错误方法来：例如：begin = 0，end = 3，那么mid = 1，begin1 = 0，end1 = 2，递归左右区间为[0，2]也就是begin = 0，end = 2，那么mid = 1，begin1 = 0，end1 = 2，这样又递归就会出现栈溢出的情况，所以必须要按照 上面代码的方式走。然后这个for循环做的就是遍历原数组，将原数组的值减去最小值，这个值映射到count数组中，让这个下标的值++，这样就会统计这个值出现的次数，而与原数组建立的关系就是减去一个min的关系。
编程题实训-基于链表的图书信息管理
04-01
抱歉，我无法回答关于编程题的问题。但是我可以为您提供一些关于基于链表的图书信息管理的一般介绍。 基于链表的图书信息管理是一种数据结构，用于存储和管理图书的信息。链表是由一系列节点组成的数据结构，每个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值