数据结构（c语言版 第2版）第2章线性表算法设计题

于 2024-10-12 21:51:21 发布
阅读量535 收藏 1
点赞数 13
CC 4.0 BY-SA版权
文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xwylovexixi/article/details/142887458

(1)将两个递增的有序链表合并为一个递增的有序链表。要求结果链表仍使用原来两个链表的存储空间，不另外占用其他的存储空间。表中不允许有重复的数据。

/*将两个有序递增链表合并成一个有序递增链表，要求结果仍使用原来两个链表的存储空间，不另外占有空间。*/
#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 20;
typedef struct LNode{
    int data;
    struct LNode *next;
} LNode,*LinkList;
LinkList mergelinklist(LinkList La,LinkList Lb){
//已知链表La,Lb的元素按递增排序。
//将两链表合并，仍然使用La的表头，将两个表比较，依次将存储空间连到La上。
//要合并后的链表仍然是递增的，需要尾插法。
    LinkList pa,pb;   //定义两个指针又来存储La,lb从首元结点开始向后的链表
    pa=La->next;     //La链表已经赋值给了pa,这样就可以使用La的头结点，作为新链表的头结点。
    pb=Lb->next;    
    free(Lb);       //Lb从首元结点开始已经赋值给了pb，所以把Lb，的头结点释放。
    LinkList last=La;      //last存储尾结点的地址。
    while(pa&&pb){
        if(pa->data<pb->data)
        {
            LinkList p=pa->next;  //先把pa的下一个结点地址存储下来。
            pa->next=NULL;        //用尾插法将pa当前结点插入La。
            last->next=pa;    
            last=last->next;
            pa=p;                //pa后移一位。
        }
        else if(pa->data==pb->data){  //值相等的情况
            LinkList p=pa->next;      //将pa当前结点插入La.
            pa->next=NULL;     
            last->next=pa;
            last=last->next; 
            pa=p;             //pa后移一位
            LinkList q=pb;
            pb=pb->next;        //释放当前结点，并且后移一位
            free(q);
        }
        else{
            LinkList p=pb->next;  //指向pb后一个结点 
            pb->next=NULL;     //把pb结点的next置空 
            last->next=pb;    //此时pb中的元素比pa中的小，应把pb链接到pa的前面 
            last=last->next;   //把last指针后移，保持last一直指向最后一个结点 
            pb=p;              //pb后移一位，对下一个结点元素进行与pa的比较 
        }
    }
    last->next=pa?pa:pb;   //pa,pb哪一个链表还没完，就将它连接到La后面。
    return La;
}
int main(){
    LinkList La,Lb;
    int n,m,i;
    La=(LinkList)malloc(sizeof(LNode));
    La->next=NULL;
    Lb=(LinkList)malloc(sizeof(LNode));
    Lb->next=NULL;
    LinkList last=La;
    printf("请输入第一个有序递增表的长度:");
    scanf("%d",&n);
    printf("\n");
	printf("请输入第一个有序递增表的元素:"); 
    for(i=0;i<n;i++)
    {
        LinkList p;
        p=(LinkList)malloc(sizeof(LNode));
        scanf("%d",&p->data);
        p->next=NULL;
        last->next=p;
        last=last->next;
    }
    last=Lb;
    printf("\n");
    printf("请输入第二个有序递增表的长度：");
    scanf("%d",&m);
	printf("\n");
	printf("请输入第二个有序递增表的元素:");   
    for(i=0;i<m;i++)
    {
        LinkList p;
        p=(LinkList)malloc(sizeof(LNode));
        scanf("%d",&p->data);
        p->next=NULL;
        last->next=p;
        last=last->next;
    }
    printf("\n");
    La=mergelinklist(La,Lb);
    LinkList p=La;
    p=p->next;
    printf("合并后的有序表为："); 
    while(p){
        printf("%d   ",p->data);
        p=p->next;
    }
    printf("\n");
    return 0;   
}

(4)已知两个链表A和B分别表示两个集合，其元素递增排列。请设计算法求出两个集合A和B的差集(仅由在A中出现而不在B中出现的元素所构成的集合)，并将结果以同样的形式存储，同时返回该集合的元素个数。

#include<iostream> 
using namespace std;
 
//创建结构体 
typedef struct PNode{  
    int val;  	//指数 
    struct PNode  *next;	//指针域 
}PNode,*lb; 
 
//创建链表及链表内容递增排序 
void CreateList(lb &P,int n){
	lb s,pre,q;
	P=new PNode;
	P->next=NULL;
	for(int i=1;i<=n;++i)
	{
		s=new PNode;
		cin>>s->val;
		pre=P;
		q=P->next;
		while(q&&q->val<s->val){
			pre=q;
			q=q->next; 
		} 
		s->next=q;
		pre->next=s;
		
	}
}
//输出每个链表内容 
void declare(lb L){
	PNode *p;
	p=L->next;
	cout<<":";
	while(p){			//循环输出链表 
	cout<<p->val<<" ";
	p=p->next;
	}
}
//求公共交集部分 
void publiclist(lb &LA,lb &LB,lb &LC)				//链表A和链表B，链表C保存交集再赋值给链表A 
{
    PNode *pa;PNode *pb;PNode *pc;PNode *p;			//定义四个指针 
    pa=LA->next;									//把链表A的初值赋给指针pa 
	pb=LB->next;									//把链表B的初值赋给指针pa 
    LC=LA;											//把链表A赋给链表C 
    pc=LC;											//链表C的初值赋给指针pc 
    while(pa&&pb)									//pa和pb不能为空 
    {
        if(pa->val==pb->val)
        {
            pc->next=pa;
            pc=pa;
            pa=pa->next;
            pb=pb->next;
        }
        else if (pa->val<pb->val)
            pa=pa->next;
        else
            pb=pb->next;
    }
    pc->next=NULL;
    LA=LC;
    delete LB;
}
 
int main()
{
	lb LA;lb LB;lb LC;int n;	//定义结构指针变量A，B，C（变量C是保存公共部分） 
	cout<<"请输入创建的A集合元素的个数："<<endl;
	cin>>n;						//输入链表A包含的个数 
	cout<<"请依次存入的数据："<<endl;
	CreateList (LA,n);			//输出链表B的内容 
 
 
	cout<<"请输入创建的B集合元素的个数："<<endl;
	cin>>n;						//输入链表B包含的个数 
	cout<<"请依次存入的数据："<<endl;
	CreateList (LB,n);			//输出链表B的内容 
 
 
	cout<<"集合A为：";
	declare(LA);			//输出链表A 
	cout<<"集合B为：";
	declare(LB);			//输出链表B 
 
	publiclist(LA,LB,LC);		//公共部分交集 
	cout<<"二者的交集为：";
 
	declare(LA);
	return 0;
}

(6)设计一个算法，通过一趟遍历确定长度为n的单链表中值最大的结点。

/*
*title:P53页程序设计第6题
*writer:weiyuexin
*data:2020-9-26
*/

#include<iostream>

using namespace std;

#define ElemType int

typedef struct LNode{
    ElemType data;   //定义数据域
    struct LNode *next;
}LNode,*LinkList;

void CreateList(LinkList &L){

    L = new LNode;     //申请存储空间
    L->next = NULL;

    int n;
    cout<<"请输入单链表的长度："<<endl;
    cin>>n;

    LinkList r = L;

    cout<<"请输入单链表的数据元素："<<endl;
    for(int i=0;i<n;i++){
        LinkList p = new LNode;
        cin>>p->data;
        p->next = NULL;
        r->next = p;
        r = p;
    }
}

void Display(LinkList L){
    LinkList p = L->next;
    while(p){
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}

void FindMax(LinkList L){
    int max = L->next->data;
    LinkList p = L->next;
    int i = 1,maxnode;
    while(p){
        if(p->data > max){
            max = p->data;
            maxnode = i;
        }
        p = p->next;
        ++i;
    }
    cout<<max<<"     ";
    cout<<maxnode<<endl;
}
int main(){
    cout<<"P53页第7题："<<endl;
    cout<<endl;
    LinkList L;
    CreateList(L);
    cout<<"初始化后的单链表为："<<endl;
    Display(L);
    cout<<"该单链表中数据元素最大值以及最大值对应的结点分别为："<<endl;
    FindMax(L);
    return 0;
}

(8)设计一个算法，删除递增有序链表中值大于mink且小于maxk的所有元素(mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同)。

#include<stdio.h>
#include<stdlib.h>

 
typedef struct node
{
	int data;
	struct node *next;
} Node,*List;
 
void Create(List &L,int n)
{
	Node *p,*rear;
	L=(Node *)malloc(sizeof(Node));
	L->next=NULL;
	rear=L;
	while(n--)
	{
		p=(Node *)malloc(sizeof(Node));
		scanf("%d",&p->data);
		p->next=rear->next;
		rear->next=p;
		rear=p;
	}
}
 
void Delete(List &L,int mink,int maxk)
{
	Node *p,*q;
	p=L;
	while(p->next)
	{
		if(p->next->data >= mink && p->next->data <= maxk)
		{
			q=p->next;
			p->next=q->next;
			free(q);
		}
		else
		{
			p=p->next;
		}
	}
}
 
int main()
{
	int n;
	List L;
	Node *p;
	int mink,maxk;
	while(1)
	{
		printf("请输入单链表的长度：");
		scanf("%d",&n);
		printf("请输入单链表的数据元素：");
		if(n==0)
			break;
		Create(L,n);
			printf("给定mink和maxk:");
		scanf("%d %d",&mink,&maxk);
		Delete(L,mink,maxk);
		p=L->next;
		int first=1;
		while(p)
		{
			if(first)
			{
				printf("%d",p->data);
				first=0;
			}
			else
			{
				printf(" %d",p->data);
			}
			p=p->next;
		}
		printf("\n");
	}
	return 0;
}

 

 

评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值