[NEFU锐格】 数据结构 实验一

最新推荐文章于 2022-12-19 23:59:04 发布
最新推荐文章于 2022-12-19 23:59:04 发布
阅读量333 收藏 1
点赞数 2
文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65022282/article/details/127094625
版权

1.8559

#include <stdio.h>
int main()
{
    int n;
    int x;
    scanf("%d",&n);
    int a[1000];
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        printf("%d ",a[i]);
    }
    printf("\n");
     for(int i=1;i<=n/2;i++)
     {
         x=a[i];
         a[i]=a[n-i+1];
         a[n-i+1]=x;
     }
     for(int i=1;i<=n;i++)
     {
         printf("%d ",a[i]);
     }
     return 0;
}

2.8553

#include <stdio.h>
#include <stdlib.h>
typedef struct node{
    int data;
    struct node *next;
}LNode;
int main()
{
    LNode *h,*r;
    h=(LNode *)malloc(sizeof(LNode));
    h->next=NULL;
    r=h;
     int n;
    while(scanf("%d",&n))
    {
        if(n==0) break;
        LNode *p;
        p=(LNode *)malloc(sizeof(LNode));
        p->data=n;
        p->next=r->next;
        r->next=p;
        r=p;
    }
    LNode *p;
    p=h->next;
    while(p!=NULL){
        printf("%d ",p->data);
        p=p->next;
    }
    return 0;
}

3.8554

#include <bits/stdc++.h>
using namespace std;
typedef struct node{
    int data;
    struct node *next;
}LNode,*LList;
void CREAT(LNode* &h){
    LList p,r;
    h=(LNode *)malloc(sizeof(LNode));
    h->next=NULL;
    r=h;
    int n;
    while(cin>>n){
        if(n==0) break;
        p=(LNode *)malloc(sizeof(LNode));
        p->data=n;
        p->next=r->next;
        r->next=p;
        r=p;
    }
}
void NIZHI(LNode* &h){
    LList p,q;
    p=h->next;
    h->next=NULL;
    while(p!=NULL){
        q=p;
        p=p->next;
        q->next=h->next;
        h->next=q;
    }
}
void PRINT(LNode *h){
    LList p;
    p=h->next;
    while(p!=NULL){
        cout<<p->data<<' ';
        p=p->next;
    }
}
int main()
{
       LList h;
       CREAT(h);
       NIZHI(h);
       PRINT(h);
       return 0; 
}

4.8555

#include <bits/stdc++.h>
using namespace std;
typedef struct node{
    int data;
    struct node *next;
}LNode;
void creat(LNode* &h){
    int n;
    LNode *p,*q,*pre;
    h=(LNode *)malloc(sizeof(LNode));
    h->next=NULL;
    while(cin>>n){
        if(n==0) break;
        p=(LNode *)malloc(sizeof(LNode));
        p->data=n;
        pre=h;
        q=h->next;
        while(q&&q->data<p->data){
            pre=q;
            q=q->next;
        }
        p->next=q;
        pre->next=p;
    }
}
void PRINT(LNode *h){
    LNode *p;
    p=h->next;
    while(p){
        cout<<p->data<<' ';
        p=p->next;
    }
}
int main()
{
    int n;
    LNode *h;
    creat(h);
    PRINT(h);
    return 0;                                                                               
}

5.8556

#include <bits/stdc++.h>
using namespace std;
typedef struct node{
    int data;
    struct node *next;
}LNode;
void creat(LNode* &h){
    h=(LNode *)malloc(sizeof(LNode));
    h->next=NULL;
    LNode *r;
    r=h;
    int n;
    while(cin>>n){
        if(n==0) break;
        LNode *p;
        p=(LNode *)malloc(sizeof(LNode));
        p->data=n;
        p->next=r->next;
        r->next=p;
        r=p;
    }
}
void DELETE(LNode* &h){
    LNode *p,*pre;
    p=h->next;
    pre=h;
    while(p!=NULL){
        if((p->data)%2==0) {pre->next=pre->next->next; p=p->next;}
       else{ pre=p;
        p=p->next;}
    }
}
void print(LNode *h){
    LNode *p;
    p=h->next;
    while(p!=NULL){
        cout<<p->data<<' ';
        p=p->next;
    }
}
int main(){
    LNode *h;
    creat(h);
    DELETE(h);
    print(h);
    return 0;
}

6.8557

#include <bits/stdc++.h>
using namespace std;
typedef struct node{
    int data;
    struct node *next;
}LNode;
void creat(LNode* &h){
    int n;
    LNode *p,*q,*pre;
    h=(LNode *)malloc(sizeof(LNode));
    h->next=NULL;
    while(cin>>n)
    {
        if(n==0) break;
        p=(LNode *)malloc(sizeof(LNode));
        p->data=n;
        pre=h;
        q=h->next;
        while(q&&q->data<p->data){
            pre=q;
            q=q->next;
        }
        p->next=q;
        pre->next=p;
    }
    
}
void PRINT(LNode *h){
    LNode *p;
    p=h->next;
    while(p!=NULL){
        cout<<p->data<<' ';
        p=p->next;
    }
}
void ADD(LNode* &a,LNode* &b){
    LNode *p1,*p2,*p3,*p;
    p1=a->next;
    p2=b->next;
    p3=a;
    while(p1&&p2){
        if(p1->data<p2->data){
           p3->next=p1;
           p3=p1;
           p1=p1->next;
        }
        else if(p1->data>p2->data){
            p3->next=p2;
            p3=p2;
            p2=p2->next;
        }
        else if(p1->data==p2->data){
            p3->next=p1;
            p3=p1;
            p1=p1->next;
        }
        p3->next=p1?p1:p2;
    }
}
void REVERSE(LNode* &h){
    LNode *p,*q;
    p=h->next;
    h->next=NULL;
    while(p){
        q=p;
        p=p->next;
        q->next=h->next;
        h->next=q;
    }
}
int main()
{
    LNode *h,*m;
    creat(h);
    creat(m);
    ADD(h,m);
    REVERSE(h);
    PRINT(h);
    return 0;
}

7.8558

#include <bits/stdc++.h>
using namespace std;
typedef struct node{
    int data;
    struct node *next;
}LNode;
void creat(LNode* &h){
    h=(LNode *)malloc(sizeof(LNode));
    h->next=NULL;
    LNode *r,*p;
    r=h;
    int n;
    while(cin>>n){
        if(n==0) break;
        p=(LNode *)malloc(sizeof(LNode));
        p->data=n;
        p->next=r->next;
        r->next=p;
        r=p;
    }
}
void sep1(LNode* &h){
    LNode *p;
    p=h->next;
    while(p){
        if((p->data)%2!=0) cout<<p->data<<' ';
        p=p->next;
    }
}
void sep2(LNode *h){
    LNode *p;
    p=h->next;
    while(p){
        if((p->data)%2==0) cout<<p->data<<' ';
        p=p->next;
    }
}
int main()
{
    LNode *h;
    creat(h);
    sep1(h);
    cout<<endl;
    sep2(h);
    return 0;
}

8.8560

#include <bits/stdc++.h>
using namespace std;
typedef struct node{
    int x;
    int z;
    struct node *next;
}LNode;
void creat(LNode* &h,int n){
    LNode *q,*pre;
    h=(LNode *)malloc(sizeof(LNode));
    h->next=NULL;
    for(int i=1;i<=n;i++){
        LNode *p;
        p=(LNode *)malloc(sizeof(LNode));
        scanf("%d,%d",&p->x,&p->z);
        pre=h;
        q=h->next;
        while(q!=NULL&&q->z<p->z){
            pre=q;
            q=q->next;
        }
        p->next=q;
        pre->next=p;
    }
}
void ADD(LNode* &a,LNode* &b){
    LNode *p1,*p2,*p3;
    int sum;
    p1=a->next;
    p2=b->next;
    p3=a;
    while(p1&&p2){
        if(p1->z==p2->z){
            sum=p1->x+p2->x;
            if(sum!=0){
                p1->x=sum;
                p3->next=p1;
                p3=p1;
                p1=p1->next;
                p2=p2->next;
            }
            else {
                p1=p1->next;
                p2=p2->next;
            }
        }
        else if(p1->z<p2->z){
            p3->next=p1;
            p3=p1;
            p1=p1->next;
        }
        else{
            p3->next=p2;
            p3=p2;
            p2=p2->next;
        }
    }
    p3->next=p1?p1:p2;
    
}
void print(LNode *h){
    LNode *p;
    p=h->next;
    while(p){
        printf("%d*x^%d ",p->x,p->z);
        p=p->next;
    }
}
int main(){
    LNode *h,*j;
    int n,m;
    cin>>n;
    creat(h,n);
    cin>>m;
    creat(j,m);
    ADD(h,j);
    print(h);
    return 0;
}

嘟~~
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
[NEFU锐格 数据结构]实验一 线性表有关的操作
鱼竿钓鱼干
09-08 2369
[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;
C语言数据结构理解语句L = (LNode * )malloc(sizeof(LNode))；
热门推荐
Gusha_的博客
11-08 1万+
对于刚开始学数据结构的同学来说，在初始化单链表的算法中，语句//L = (LNode * )malloc(sizeof(LNode));//可能不太好理解(至少我是这样)。那么下面我就来详细的解释一下该语句: #include<stdlib.h> ​//构造单链表数据 typedef struct LNode{ ElemType data; struct LNode *next; }LNode; //初始化线性表 void InitList(LNode &L...
C语言萌新，求指点
LittleControl的博客
09-29 250
C语言新手，用单循环链表写约瑟夫环问题，但老是遇到这种情况 以下为源代码`#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;malloc.h&gt; typedef struct node { int num; int password; struct node *next; }Lnode; Lnode t; voi...
c语言建立链表叫LNode,C语言链表基本操作
weixin_32999557的博客
05-21 1275
链表的建立、插入、查找、倒置、删除等操作//链表操作:建立、插入、删除、查找、倒置、删除等基本操作//喜洋洋制作#include#includetypedefstructLNode{intdata; structLNode *next;}LNode,*Llist;LNode *creat_head();//创建一个空表void creat_list(LNode *,int);//创建一个长度为n的...
【数据结构】单链表应用3
m0_73866527的博客
12-19 172
1，多项式加法：与有序表的合并是一样的思路，从a链表头结点开始创建一个新的链表（指向头结点设置一个指针，这个指针是专门用作连结的，比如说单链表应用1里的删除A链表中与B重复的元素里、尾插法里的r、单链表应用2，3，都有设置这样的指针），然后设置两个指针，分别指向两个链表的首元结点。 然后就是依此比较指数..... //实现两个多项式相加，并输出 typedef struct Pnode{ int coef;//系数 int expn;//指数 struct Pnode *next; }Pnode
【NEFU锐格】数据结构实验二
qq_65022282的博客
10-28 532
NEFU数据结构
2022-nefu-数据结构课设完整版本
09-27
在这个“2022-nefu-数据结构课设完整版本”中，我们可以看到一个针对东北林业大学（NEFU）学生的数据结构课程设计项目。这个项目的完整版本包括了源码，这意味着我们可以深入学习和理解每个数据结构的实现细节。 ...
NEFU锐格网络平台（实验课）用于莫拉莱斯存储锐格做过的题。.zip
03-29
【NEFU锐格网络平台】是一个专为教育领域设计的在线网络平台，尤其适用于莫拉莱斯存储和管理学生在锐格上完成的题目。这个平台可能是为了方便教学、实践和学习过程中的作业提交与批改而开发的。从标题来看，这个平台...
NEFU计组实验1 寄存器实验 .rar
06-05
NEFU2020.6.5计算机组成原理实验logisim文件，仅供参考，参考，参考 实验目的： 一、 实验目的 理解并掌握存储器的读、写操作过程 理解存储操作中锁存脉冲的作用 掌握存储操作中时序电路的作用 实验内容： 学会对MAR...
NEFU计算机组成原理实验一寄存器实验
05-14
寄存器实验的logisim源文件，一共有7个，分为main，直传电路，左移电路，右移电路，选择电路，寄存器使用示例，总线连接模式示例
NEFU计组实验2 运算器实验 .rar
06-05
NEFU2020.6.5计算机组成原理实验logisim文件，仅供参考，参考，参考 实验目的 掌握模拟过程中算术、逻辑运算单元的控制方法 理解寄存器组中寄存器数据输出的方法 实验内容 有8种运算，通过S2，S1，S0 来选择，具体...
俩单链表数据交叉合并
qq_42764860的博客
04-19 634
#include <iostream.h> typedef struct LNode{ int data;//数据域 struct LNode *next;}LinkList; //构造一个单链表结构体 void CreateList(LinkList *&L,int a[],int n){ LinkList *s,*r;//s为新节点，r为尾节点 L=new LNode;/...
C语言 ，嵌入式 ，数据结构 面试题目（3）
constantin_的博客
03-13 1579
182 链表题：一个链表的结点结构struct Node{int data ;Node *next ;};typedef struct Node Node ;(1)已知链表的头结点head,写一个函数把这个链表逆序 ( Intel)Node * ReverseList(Node *head) //链表逆序{if ( head == NULL || head-&gt;next == NULL )re...
大学生创业计划书(30)-两份资料.doc
08-20
大学生创业计划书(30)-两份资料.doc
学习DXP编辑多个对像
08-20
DXP编辑多个对像
基于Matlab编程的直线检测实现[Matlab编程].zip
08-20
MATLAB提供了多种直线检测技术，其中包括以下几种常用的方法： 1. Hough变换：Hough变换是一种基于极坐标空间的直线检测方法，通过将直线表示为参数空间中的点，将图像中的直线检测问题转化为参数空间中的点集聚类问题。MATLAB中的函数'hough'和'houghlines'可以实现Hough变换直线检测。 2. 边缘检测+RANSAC：先使用边缘检测方法（如Sobel、Canny等）提取图像中的边缘，然后使用RANSAC算法拟合直线模型。MATLAB中的函数'edge'可以进行边缘检测，而函数'fitline'可以使用RANSAC算法进行直线拟合。 3. 直线分段检测：将图像中的直线分段，在每个段上进行直线拟合。常见的方法包括分段最小二乘法、分段Hough变换等。MATLAB中的函数'fitline'可以对图像中的曲线进行分段直线拟合。 4. 基于模型的直线检测：根据直线的几何模型进行直线检测，常见的方法包括RANSAC算法、最小二乘法等。MATLAB中的函数'fitline'可以实现基于模型的直线检测。 以上是一些常用的MATLAB直线检测技术，具体的选择要根据实
网络防火墙：数字世界的守卫者
08-20
【计算机网络开发】通常指的是开发计算机网络相关的软件和系统，包括但不限于以下几个方面： 1. **网络协议开发**：设计和实现用于网络通信的协议，如TCP/IP、HTTP、FTP等。 2. **网络应用开发**：开发运行在网络上的应用程序，如网页浏览器、电子邮件客户端、文件共享应用等。 3. **网络服务开发**：创建和管理网络服务，例如Web服务、数据库服务、云服务等。 4. **网络安全**：开发用于保护网络安全的软件，包括防火墙、入侵检测系统、加密技术等。 5. **网络设备驱动程序开发**：为网络硬件设备编写驱动程序，如网卡、路由器、交换机等。 6. **网络管理工具**：开发用于网络监控、管理和故障排除的工具。 7. **嵌入式网络系统**：开发用于嵌入式设备（如智能家居设备、工业控制系统）的网络功能。 8. **网络编程语言和框架**：使用特定的编程语言和框架（如Python、Java、Node.js等）进行网络应用的开发。 9. **分布式系统开发**：设计和实现分布式计算系统，这些系统可以跨多个物理位置运行。 10. **网络性能优化**：优化网络应用和系统的性能，确保
最新linux系统命令（经典）
最新发布
08-20
###################################################################### 1. 本站所有资源来源于用户上传和网络，如有侵权请邮件联系站长！ 2. 分享目的仅供大家学习和交流，您必须在下载后24小时内删除！ 3. 不得使用于非法商业用途，不得违反国家法律。否则后果自负！ 4. 本站提供的源码、模板、插件等等其他资源，都不包含技术服务请大家谅解！ 5. 如有链接无法下载、失效或广告，请联系管理员处理！ 6. 本站资源售价只是赞助，收取费用仅维持本站的日常运营所需！ 7. 如遇到加密压缩包，请使用WINRAR解压,如遇到无法解压的请联系管理员！ 8. 精力有限，不少源码未能详细测试（解密），不能分辨部分源码是病毒还是误报，所以没有进行任何修改，大家使用前请进行甄别！
nefu算法设计与分析
05-17
东北林业大学（NEFU）的算法设计与分析是一门涵盖算法基础知识、算法设计和分析等方面的课程。该课程主要包括以下内容： 1. 算法的时间复杂度和空间复杂度 2. 基本数据结构：数组、链表、栈、队列、树、图等 3. 排序算法：冒泡排序、选择排序、插入排序、快速排序、归并排序等 4. 查找算法：线性查找、二分查找等 5. 图算法：最短路径、最小生成树、拓扑排序等 6. 动态规划：背包问题、最长公共子序列、最优二叉搜索树等 7. 网络流算法：最大流、最小割等 在学习过程中，学生需要掌握算法的基本概念和设计思想，能够使用常见算法解决实际问题，并且能够对算法进行正确的分析和评估。此外，学生还要具备使用编程语言实现算法的能力。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值