大二数据结构锐格实验题（栈和队列）

最新推荐文章于 2023-09-20 13:48:32 发布
最新推荐文章于 2023-09-20 13:48:32 发布
阅读量1.4k 收藏 19
点赞数 1
分类专栏： 大二数据结构 文章标签： 指针 单链表 算法 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46126118/article/details/109809823
版权

1、随机产生或键盘输入一组元素，建立一个带头结点的单向链表（无序）；
2、把单向链表中元素逆置（不允许申请新的结点空间）；
3、在单向链表中删除所有的偶数元素结点；
4、编写在非递减有序链表中插入一个元素使链表元素仍有序的函数。
5、利用算法4建立两个非递减有序单向链表，然后合并成一个非递增链表。
6、利用算法4建立两个非递减有序单向链表，然后合并成一个非递减链表。
7、一元多项式的存储并实现两个多项式相加。
1、随机产生或键盘输入一组元素，建立一个带头结点的单向链表（无序）；

.#include <iostream>
#include <bits/stdc++.h>
using namespace std;
typedef struct l
{
    int data;
    struct l *next;
}linelist;
linelist *creat()
{
    int x;
    linelist *head;
    linelist *p;
    head=new linelist;head->next=NULL;
    p=head;
    while(1)
    {
        scanf("%d",&x);
        if(x==0) break;//输入为零终止输入（表示链表建立完成）
        linelist *s;
        s=new linelist;
        s->data=x;s->next=p->next;
        p->next=s;
        p=s;
    }
    p->next=NULL;
    return head;
}
void output(linelist *L)
{
    linelist *p;
    p=L->next;
    while(p!=NULL)
    {
        printf("%d ",p->data);
        p=p->next;
    }
}
int main()
{
    linelist *L;
    L=creat();
    output(L);
    return 0;
}

2单链表元素逆置
不开辟新的空间只改变指针指向

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
typedef struct LinkList
{
    int data;
    struct LinkList *next;
}LinkList;
LinkList* CreateList()//尾插法建立链表
{
    int temp;
    LinkList *head;
    LinkList *rear;
    rear=new LinkList;
    head=new LinkList;
    head=rear;
    rear->next=NULL;
    while(1)
    {
        scanf("%d",&temp);//输入数据
        if(temp==0)
        {
            break;
        }
        LinkList *knot;
        knot=new LinkList;
        knot->data=temp;
        rear->next=knot;
        rear=knot;
    }
    return head;
}
void inverse(LinkList *head)//逆置链表中元素
{
    LinkList *temp,*temp2;
    temp=head->next;//temp指向首元节点
    head->next=NULL;
    while(temp!=NULL)//遍历链表，直到表尾
    {
        temp2=temp->next;
        temp->next=head->next;//将摘取的节点插入到头结点后面
        head->next=temp;
        temp=temp2;
    }
}
void DisplayList(LinkList *head)//输出链表
{
    head=head->next;
    while(head->next!=NULL)
    {
        printf("%d ",head->data);
        head=head->next;
    }
    printf("%d\n",head->data);
}
int main()
{
    LinkList *head;
    head=CreateList();
    inverse(head);
    DisplayList(head);
    return 0;
}

3.删除所有偶元素节点
先存一下每个链表的前驱，然后判断每个数据是否为偶数，是就删掉

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
typedef struct LinkList
{
    int data;
    struct LinkList *next;
}LinkList;
LinkList* CreateList()//建立单链表
{
    int temp;
    LinkList *head;
    LinkList *rear;
    rear=new LinkList;
    head=new LinkList;
    head=rear;
    rear->next=NULL;
    while(1)
    {
        scanf("%d",&temp);
        if(temp==0)
        {
            break;
        }
        LinkList *knot;
        knot=new LinkList;
        knot->data=temp;
        rear->next=knot;
        rear=knot;
    }
    return head;
}
void inverse(LinkList *head)
{
    LinkList *temp,*temp2;
    temp=head->next;
    head->next=NULL;
    while(temp!=NULL)
    {
        temp2=temp->next;
        temp->next=head->next;
        head->next=temp;
        temp=temp2;
    }
}
void DisplayList(LinkList *head)
{
    head=head->next;
    while(head->next!=NULL)
    {
        printf("%d ",head->data);
        head=head->next;
    }
    printf("%d\n",head->data);
}
void Delete(LinkList *head)//
{
    LinkList *find,*pre;
    find=head->next;
    pre=head;
    while(find!=NULL)//核心
    {
        if((find->data)%2==0)//若是偶元素的节点就删除
        {
            pre->next=find->next;
            find=pre->next;
        }
        else//若非偶元素节点则指向下一个
        {
            pre=find;
            find=find->next;
        }
    }
}
int main()
{
    LinkList *head;
    head=CreateList();
    Delete(head);
    DisplayList(head);
    return 0;
}

4.编写在非递减有序链表中插入一个元素使链表元素仍有序的函数

//建立非递减有序单向链表
#include <iostream>
using namespace std;
#define Maxsize 100
typedef struct LinkList
{
    int data;
	struct LinkList* next;
}LinkList;
LinkList* InitList()
{
	LinkList* L;
	L = new LinkList;
	L->next = NULL;
	LinkList* temp1, * temp2;
	int x;
	while (cin >> x && x)//输入x 当x=0时停止输入
	{
		LinkList* knot;
		knot = new LinkList;
		knot->data = x;
		temp1 = L;
		temp2 = L->next;
		while (temp2)//每输入一个数就遍历一次链表
		{
			if (temp2->data > x)//找到值比x大的节点，将其插入
			{
				break;
			}
			temp1 = temp2;
			temp2 = temp2->next;
		}
		knot->next = temp1->next;
		temp1->next = knot;
	}
	return L;
}
void DisplayList(LinkList *head)//输出链表
{
	head = head->next;
	while (head->next != NULL)
	{
		cout << head->data<<" ";
		head = head->next;
	}
	cout << head->data << endl;
}
int main()
{
	LinkList* L;
	L = InitList();
	DisplayList(L);
	return 0;
}

5利用算法4建立两个非递减有序单向链表，然后合并成一个非递增链表。

//两非递减链表变成一非递增链表
#include <iostream>
using namespace std;
#define Maxsize 100
typedef struct LinkList
{
    int data;
	struct LinkList* next;
}LinkList;
LinkList* InitList()//建立一个非递减链表
{
	LinkList* L;
	L = new LinkList;
	L->next = NULL;
	LinkList* temp1, * temp2;
	int x;
	while (cin >> x && x)//有序链表的创建
	{
		LinkList* knot;
		knot = new LinkList;
		knot->data = x;
		temp1 = L;
		temp2 = L->next;
		while (temp2)
		{
			if (temp2->data > x)
			{
				break;
			}
			temp1 = temp2;
			temp2 = temp2->next;
		}
        knot->next = temp1->next;
        temp1->next = knot;
	}
	return L;
}
void DisplayList(LinkList *head)
{
	head = head->next;
	while (head->next != NULL)
	{
		cout << head->data<<" ";
		head = head->next;
	}
	cout << head->data << endl;
}
LinkList* Addition(LinkList* L1, LinkList* L2)//两递增链表变成一递减链表
{
	LinkList *temp,*L3,*p1,*p2,*p3;
	p1=L1->next;//p1为L1工作指针，初始化为首元节点
	p2=L2->next;//p2为L2工作指针，初始化为首元节点
	L3=p3=L1;
	L3->next=NULL;
	while(p1||p2)//只要有一个表非空，就指向待摘取节点元素
    {
        if(!p1)
        {
            temp=p2;
            p2=p2->next;
        }
        else if(!p2)
        {
            temp=p1;
            p1=p1->next;
        }
        else if(p1->data<=p2->data)//取p1中较小者，temp指向p1,p1后移
        {
            temp=p1;
            p1=p1->next;
        }
        Else//取p1中较小者，temp指向p1,p1后移
        {
            temp=p2;
            p2=p2->next;
        }
        temp->next=L3->next;
        L3->next=temp;
    }
    return L3;
}
int main()
{
	LinkList* L1, * L2, * L3;
	L1 = InitList();
	L2 = InitList();
	L3 = Addition(L1, L2);
	DisplayList(L3);
	return 0;
}

7.实现两多项式相加

#include <iostream>
#include <bits/stdc++.h>
using namespace std;
typedef struct LinkList
{
    int data;
    int exp;
    struct LinkList *next;
}LinkList;
LinkList* CreateList(int n)//创建链表
{
    LinkList *rear;
    LinkList *head;
    rear=new LinkList;
    head=rear;
    for(int i=1;i<=n;i++)
    {
        int temp1,temp2;
        scanf("%d,%d",&temp1,&temp2);
        LinkList *knot;
        knot=new LinkList;
        knot->data=temp1;
        knot->exp=temp2;
        rear->next=knot;
        rear=knot;
    }
    rear->next=NULL;
    return head;
}
void DisplayList(LinkList *head)
{
    head=head->next;
    while(head->next!=NULL)
    {
        printf("%d*x^%d ",head->data,head->exp);
        head=head->next;
    }
    printf("%d*x^%d\n",head->data,head->exp);
}
LinkList* Addition(LinkList *head1,LinkList *head2)//两多项式相加算法
{
    LinkList *p1,*p2,*p3;
    p3=head1;
    p1=head1->next;//p1为head1工作指针
p2=head2->next;//p2为head2工作指针
    while(p1&&p2)//p1和p2均非空
    {
        if(p1->exp>p2->exp)//p1指数大于p2指数
        {
            p3->next=p2;
            p3=p2;
            p2=p2->next;
        }
        else if(p1->exp<p2->exp)//p1指数小于p2指数

        {
            p3->next=p1;
            p3=p1;
            p1=p1->next;
        }
        else if(p1->exp==p2->exp)//若指数相等
        {
            int sum;
            sum=p1->data+p2->data;//将两系数相加
            if(sum==0)//若和为0跳过这两个节点
            {
                p1=p1->next;
                p2=p2->next;
            }
            else//若不为零修改p1当前节点系数值为两项系数的和
            {
                p1->data=sum;
                p3->next=p1;
                p3=p1;
                p1=p1->next;
                p2=p2->next;
            }
        }
    }
    if(p1==NULL)//插入非空多项式剩余段
    {
        p3->next=p2;
    }
    if(p2==NULL)插入非空多项式剩余段
    {
        p3->next=p1;
    }
    return head1;
}
int main()
{
    LinkList *temp,*head1,*head2;
    int m,n;
    cin>>m;
    head1=CreateList(m);
    cin>>n;
    head2=CreateList(n);
    temp=Addition(head1,head2);
    DisplayList(temp);
    return 0;
}
张张同学！
关注
  • 1
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
锐格系统数据结构相关习题
m0_47469819的博客
09-02 1319
线性表 題目內容: 采用单向链表实现一元多项式的存储并实现两个多项式相加并输出结果。 输入输出说明: 输入： 2x^2 3x^3 5x^5 7x^7# -2x^2 2x^3 4x^4 5x^7 9x^9# 输出： 5x^3 4x^4 5x^5 12x^7 9x^9 #include<iostream> #include <stdio.h> struct node { int co; int exp; struct node * next; }; node*
数据结构(C语言)实验教程实验数据.zip
10-29
实验数据.zip文件包含了用于实践操作的数据，这通常包括各种数据结构的示例输入，如数组、链表、树、图等，以及可能的测试用例，供你在编写和调试代码时使用。文件"shujujiegou_c"可能是这些数据结构的C语言实现源...
[NEFU]锐格 数据结构 作业
qq_65022282的博客
09-27 1233
nefu 数据结构 作业
【锐格】数据结构-线性表
Do1phln的博客
10-24 2374
欢迎加入NEFU计算机编程交流群：523539085 顺序表 4882 #include<iostream> #include<stdlib.h> using namespace std; const int defaultSize = 10; class SeqList { protected: int *data; int maxSize; //表最大可容纳项数 int last; //当前表大小 public: SeqList(int sz = defa
数据结构——单链表基本操作的实现
m0_68579349的博客
08-13 518
数据结构——王道单链表基本操作的实现
数据结构（初阶 三）单链表的实现
qq_45559559的博客
08-13 708
顺序表的实现及相关试题
NEFU锐格网络平台（实验课）用于莫拉莱斯存储锐格做过的题。.zip
最新发布
03-29
【NEFU锐格网络平台】是一个专为教育领域设计的在线网络平台，尤其适用于莫拉莱斯存储和管理学生在锐格上完成的题目。这个平台可能是为了方便教学、实践和学习过程中的作业提交与批改而开发的。从标题来看，这个平台...
锐格测试.cpp
04-05
锐格测试.cpp
大一上实验5_2.cpp
07-06
彻底了解指针数组，数组指针，以及函数指针，以及堆中的分配规则
大一C语言答案大全.zip
06-21
http://124.160.107.91:9021/indexcs/simple.jsp?loginErr=0 电子信息类 大一学年C语言修晓杰 课后答案
数据结构与算法:单向链表实现与封装
08-26
今天小编就为大家分享一篇关于数据结构与算法:单向链表实现与封装，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
java单向链表的实现实例
09-04
java单向链表的实现实例。需要的朋友可以过来参考下，希望对大家有所帮助
单向链表 操作 经典
04-03
本程序采用指向指针的指针来完成单链表的各种操作 插入、删除、逆转、按地址排序、递归的归并算法
通俗易懂说单链表（3）合并两个有序链表
哈尼的博客
05-05 393
通俗易懂说单链表（3）合并两个有序链表1. 递归实现2. 非递归实现 1. 递归实现 typedef struct node{ int value; struct node *next; }Node, *pNode; //采用递归的方法实现 Node *SingleListMerge(Node *head1,Node *head2) { if(head1==NULL) return h...
合并两个排序的链表
Eric_qiushui的博客
06-07 251
文章目录一、题目描述二、题目解析 一、题目描述 输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。 题目来源：合并两个排序的链表 二、题目解析 /* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } };*/...
数据结构-链表（C语言）
CC的博客
07-23 1436
数据结构-链表详解（C语言）
[NEFU锐格 数据结构]实验一 线性表有关的操作
鱼竿钓鱼干
09-08 2360
[NEFU锐格 数据结构]实验一 线性表有关的操作 题目 8599 #include<stdlib.h> #include<stdio.h> #include<string.h> #include<math.h> int arr[15]; int n; int main(){ scanf("%d",&n); for(int i=0;i<n;i++)scanf("%d",&arr[i]); for(int i=0;
编写在非递减有序链表中插入一个元素(整型)，使链表元素仍有序的函数（必须采用函数实现，否则不算成绩），并利用该函数建立一个非递减有序单向链表，之后输出这个有序的单链表。
2301_76327397的博客
09-20 497
【代码】编写在非递减有序链表中插入一个元素(整型)，使链表元素仍有序的函数（必须采用函数实现，否则不算成绩），并利用该函数建立一个非递减有序单向链表，之后输出这个有序的单链表。
锐格网络平台数据结构
10-12
锐格网络平台的数据结构主要包括以下几个方面： 1. 用户数据结构：包括用户基本信息、账号密码、权限等； 2. 文章数据结构：包括文章标题、内容、作者、发布时间等； 3. 评论数据结构：包括评论内容、评论者、评论...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值