SDUT数据结构pta-实验二 链表

于 2024-10-05 08:24:06 发布
阅读量121 收藏
点赞数 5
文章标签： 数据结构 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79894935/article/details/142710763
版权

7-1 两个有序链表序列的合并

#include<bits/stdc++.h>
using namespace std;
struct node{
    int data;
     node *next;
};
int main()
{
    int r;
    node *h1=new node;
    node *h2=new node;
    h1->next=NULL;
    h2->next=NULL;
    node *p1,*p2,*t1,*t2;
    t1=h1;
    t2=h2;
    while(true)
    {
        cin >>r;
        if(r==-1)break;
        p1=new node;
        p1->data=r;
        p1->next=NULL;
        t1->next=p1;
        t1=p1;
    }
    while(true)
    {
        cin >>r;
        if(r==-1)break;
        p2=new node;
        p2->data=r;
        p2->next=NULL;
        t2->next=p2;
        t2=p2;
    }
    node *h=new node;
    h->next=NULL;
    node *p,*t;
    t=h;
    p1=h1->next;
    p2=h2->next;
    while(p1!=NULL && p2!=NULL)
    {
        if(p1->data <= p2->data){
            p=new node;
            p->data=p1->data;
            p->next=NULL;
            t->next=p;
            t=p;
            p1=p1->next;
        }
        else {
            p=new node;
            p->data=p2->data;
            p->next=NULL;
            t->next=p;
            t=p;
            p2=p2->next;
        }
    }
    while(p1!=NULL)
    {
        p=new node;
        p->data=p1->data;
        p->next=NULL;
        t->next=p;
        t=p;
        p1=p1->next;
    }
    while(p2!=NULL)
    {
        p=new node;
        p->data=p2->data;
        p->next=NULL;
        t->next=p;
        t=p;
        p2=p2->next;
    }
    p=h->next;
    if(p==NULL){
    printf("NULL");
                return 0;}
    while(p!=NULL)
    {
        if(p->next==NULL)cout <<p->data;
        else cout <<p->data <<" ";
        p = p->next;
    }
    
}

7-2 两个有序链表序列的交集

#include<bits/stdc++.h>
using namespace std;
struct node{
    int data;
    node *next;
};
int main()
{
    int i,n,cnt=0;
    node *h1=new node;
    node *h2=new node;
    h1->next=NULL;
    h2->next=NULL;
    node *p1,*p2,*t1,*t2;
    t1=h1;
    t2=h2;
    while(true)
    {
        cin >> n;
        if(n==-1)break;
        p1=new node;
        p1->data=n;
        p1->next=NULL;
        t1->next=p1;
        t1=p1;
    }
    while(true)
    {
        cin >> n;
        if(n==-1)break;
        p2=new node;
        p2->data=n;
        p2->next=NULL;
        t2->next=p2;
        t2=p2;
    }
    p1=h1->next;
    p2=h2->next;
    while(p1!=NULL&&p2!=NULL)
    {
        if(p1->data==p2->data){
            if(cnt==0)cout <<p1->data;
            else cout <<" "<<p1->data;
            p2=p2->next;
            p1=p1->next;
            cnt++;
        }
        else {
            if(p1->data < p2->data) {
                p1 = p1->next;
            } else {
                p2 = p2->next;
            }
        }
    }
    if(cnt==0)cout <<"NULL";
}

7-3 重排链表

#include <stdio.h>
struct node
{
    int data,next;
}a[100001];
int start,n;
int paixu[100001];
int chongpai[100001];
int main()
{
    scanf("%d %d",&start,&n);
    for(int i=0;i<n;i++){
        int p,q,w;
        scanf("%d %d %d",&p,&q,&w);
        a[p].data=q;
        a[p].next=w;
    }
    int len=0;
    for(int i=start;i>=0;i=a[i].next){
        paixu[len++]=i;
    }
    int left=0,right=len-1;
    int t=0;
    while(left<=right){
        if(left<right){
            chongpai[t++]=paixu[right];
            right--;
            chongpai[t++]=paixu[left];
            left++;
        }
        else{
            chongpai[t++]=paixu[left];
            left++;
        }
    }
    for(int i=0;i<t;i++){
        if(i!=t-1){
            printf("%.5d %d %.5d\n",chongpai[i],a[chongpai[i]].data,chongpai[i+1]);
        }
        else printf("%.5d %d -1\n",chongpai[i],a[chongpai[i]].data);
    }
    return 0;
}

7-4 约瑟夫环

#include <stdio.h>
#include <stdlib.h>
struct node {
    int data;
    struct node *next;
};
int main() {
    int n, m;
    scanf("%d %d", &n, &m);
    struct node *h = NULL, *t = NULL, *p = NULL;
    // 创建链表
    h=(struct node*)malloc(sizeof(struct node*));
    h->data=1;
    t=h;
    for (int i = 2; i <= n; i++) {
        p = (struct node*)malloc(sizeof(struct node));
        p->data = i;
        p->next = NULL;
            t->next = p; // 连接新的节点
            t = p; // 移动到新的最后节点
    }
    t->next = h; // 形成循环链表
    struct node *q = NULL;
    t = h;
    // 使用循环来执行删除操作
    while (n > 0) {
        for (int count = 1; count < m; count++) {
            q = t; // 更新前一个节点
            t = t->next; // 移动到下一个节点
        }
        // 输出被删除节点的数据
        printf("%d", t->data);
        n--; // 减少剩余节点计数
        if (n > 0) {
            printf(" "); // 输出空格分隔
        }
        // 处理删除逻辑
        if (q == NULL) {
            // 删除头节点
            h = t->next;
        } else {
            // 删除中间或尾节点
            q->next = t->next;
        }
        struct node *to = t;
        t = t->next; // 先保存下一个节点
        free(to); // 释放当前节点
    }
    return 0;
}

单链表的创建及遍历

#include<bits/stdc++.h>
using namespace std;
struct node {
    int data;
    node *next;
};

int main()
{
    int n,i;
    node *h = new node;
    h->next = NULL;
    node *p, *t;
    t = h;
    cin >> n;
    for(i = 0; i < n; i++) {
        p = new node;
        cin >> p->data; // 修正输入操作符
        p->next = NULL;
        t->next = p;
        t = p;
    }
    p = h->next;
    for(i = 0; i < n; i++) {
        if(i == 0) {
            cout << p->data;
        } else {
            cout << " " << p->data;
        }
        p = p->next;
    }
    return 0;
}

7-6 链表去重

#include <stdio.h>
struct node
{
    int key,next;
}a[100001];
int start;
int diyige[100001];
int dierge[100001];
int repeat[100001];
int main()
{
    int n;
    scanf("%d %d",&start,&n);
    for(int i=0;i<n;i++){
        int p,q,w;
        scanf("%d %d %d",&p,&q,&w);
        a[p].key=q;
        a[p].next=w;
    }
    int len1=0,len2=0;
    for(int i=start;i>-1;i=a[i].next){
        int key=abs(a[i].key);
        if(repeat[key]==0){
            repeat[key]=1;
            diyige[len1++]=i;
        }
        else{
            dierge[len2++]=i;
        }
    }
    for(int i=0;i<len1;i++){
        printf("%.5d %d ",diyige[i],a[diyige[i]].key);
        if(i==len1-1)
            printf("-1\n");
        else
            printf("%.5d\n",diyige[i+1]);
    }
    for(int i=0;i<len2;i++){
        printf("%.5d %d ",dierge[i],a[dierge[i]].key);
        if(i==len2-1)
            printf("-1\n");
        else
            printf("%.5d\n",dierge[i+1]);
    }
    return 0;
}

7-7单链表就地逆置

#include<stdio.h>
#include<stdlib.h>
typedef struct
{
    int data;
    struct node *next;
}Lnode,*LinkList;
LinkList createLinkedList()
{
    LinkList head=(LinkList)malloc(sizeof(Lnode));
    head->next=NULL;
    LinkList r=head;
    while(1){
        int value;
        scanf("%d",&value);
        if(value==-1){break;}
        LinkList p=(LinkList)malloc(sizeof(Lnode));
        p->data=value;
        p->next=NULL;
        r->next=p;
        r=p;
    }
    return head;
}
void nizhi(LinkList head)
{
    LinkList p,q;
    p=head->next;
    head->next=NULL;
    while(p){
        q=p;
        p=p->next;
        q->next=head->next;
        head->next=q;
    }
}
void Print(LinkList head)
{
    LinkList p=head->next;
    while(p){
        if(p->next!=NULL){
            printf("%d ",p->data);
            p=p->next;
        }
        else {
            printf("%d",p->data);
            p=p->next;
        }
    }
    printf("\n");
}
int main()
{
    int T;
    scanf("%d",&T);
    for(int i=0;i<T;i++)
    {
        LinkList L=NULL;
        L=createLinkedList();
        nizhi(L);
        Print(L);
    }
    return 0;
}

7-8 带头节点的双向循环链表操作

#include<bits/stdc++.h>
using namespace std;
struct node{
    int data;
    node * next;
    node *pre;
};
void puf(node *h, node *p)
{
    if (h->next == NULL) {
        h->next = p;
        p->next = h;
        p->pre = h;
    } else {
        p->next = h->next;
        h->next->pre = p;
        h->next = p;
        p->pre = h;
    }
}
void pub(node *h, node *p)
{
    if (h->next == NULL) {
        h->next = p;
        p->next = h;
        p->pre = h;
    } else {
        node *t = h->next;
        while (t->next != h) {
            t = t->next;
        }
        t->next = p;
        p->pre = t;
        p->next = h;
        h->pre = p;
    }
}
void shun(node *h)
{
    node *p = h->next;
    if (p != h) { // 添加判断条件，避免只有一个节点时的输出问题
        printf("%d", p->data);
        p = p->next;
    }
    while (p != h) {
        printf(" %d", p->data);
        p = p->next;
    }
    printf("\n");
}
void ni(node *h)
{
    node *p = h->pre;
    if (p != h) { // 添加判断条件，避免只有一个节点时的输出问题
        cout << p->data;
        p = p->pre;
    }
    while (p != h) {
        printf(" %d", p->data);
        p = p->pre;
    }
}
int main()
{
    int n, i = 0;
    node *h = new node;
    h->next = h->pre = h;
    while (~scanf("%d", &n) && n != -1)
    {
        node *p = new node;
        p->data = n;
        if (i % 2 == 0) {
            puf(h, p);
        } else {
            pub(h, p);
        }
        i++;
    }
    shun(h);
    ni(h);
    return 0;
}

7-9 头插法创建单链表、遍历链表、删除链表

#include<bits/stdc++.h>
using namespace std;
struct node{
    int data;
     node * next;
};
void deletelist(node *h) {
    node *t;
    while (h != NULL) {
        t = h;
        h = h->next;
        delete t;
    }
}
int main()
{
    int k;
    scanf("%d",&k);
    while(k)
    {
        int n,i,j;
        node * h=new node;
        h->next=NULL;
        node *p;
        while(scanf("%d",&n)!=EOF&&n!=-1)
        {
            p=new node;
            p->data=n;
            p->next=h->next;
            h->next=p;
        }
        p=h->next;
        while(p!=NULL)
        {
            cout <<p->data<<" ";
            p=p->next;
        }
        cout << endl;
        k--;
        deletelist(h);
    }
}
ja哇
关注
SDUT ACM PTA 数据结构 实验二 链表
林夕的博客
09-04 773
链表
SDUT数据结构PTA专题（实验二）题解
qq_45830025的博客
09-28 1852
数据结构与算法A实验二链表7 - 1 单链表的创建及遍历7 - 2 两个有序链表序列的合并7 - 3 单链表的创建，遍历与销毁7 - 6 删除重复字符7 - 10 链表去重7 - 11 单链表就地逆置 7 - 1 单链表的创建及遍历 #include<bits/stdc++.h> using namespace std; struct node{ // 定义节点结构体 int data; // 值 node *next; // 指向下一个节点的索引 }; node *b
PTA 7-5 C语言链表的逆置--两种实现代码
程序员早早的博客
04-09 2937
题目 C语言代码实现 关于单链表的头节点有两种方式，一种头节点直接保存数据，另外一种头节点只是作为哨兵占位。两种方式均实现一遍，掌握任何一种均可。 头节点保存数据 # include <stdio.h> # include <stdlib.h> //单链表逆置，head保存数据 typedef struct Node *node; struct Node { int data; node next; }; node createList() { no
SDUT ACM OJ PTA 实验二链表
林夕的博客
02-07 1286
A ：顺序建立链表 #include<stdio.h> #include<stdlib.h> struct node { int data; struct node *next; }*head,*tail,*p,*q; int main () { head=(struct node *)malloc(sizeof(struct node)); head->next=NULL; tail=head; int n,i;
SDUT PTA 22级数据结构与算法实验2——链表
qq_25497963的博客
11-30 486
【代码】SDUT PTA 22级数据结构与算法实验2——链表。
SDUT ACM OJ PTA 数据结构与算法实验一顺序表
林夕的博客
08-28 1739
数据结构
SDUT数据结构PTA专题（实验一）题解
qq_45830025的博客
09-27 1766
@TOC 两个有序链表序列的合并 题目链接 答案： #include<bits/stdc++.h> using namespace std; struct node{ // 定义节点结构体 int data; // 值 node *next; // 指向下一个节点的索引 }; node *build(node *head){ // 建立链表 head=new node; node *tail,*p; head->next=NULL;
SDUT PTA 21级数据结构与算法实验2——链表
sky_kin的博客
09-25 2647
例如给定 L 为 21→-15→-15→-7→15，你需要输出去重后的链表 21→-15→-7，还有被删除的链表 -15→15。例如：给定L为1→2→3→4→5→6，则输出应该为6→1→5→2→4→3。N个人围成一圈顺序编号，从1号开始按1、2、3......顺序报数，报p者退出圈外，其余的人再从1、2、3开始报数，报p的人再退出圈外，以此类推。输入多个整数，以-1作为结束标志，顺序建立一个带头结点的单链表，之后对该单链表进行就地逆置（不增加新结点），并输出逆置后的单链表数据。每组测试数据的输出占1行。
SDUT PTA 链表
qq_62846665的博客
04-15 1891
7-1 数据结构实验之链表一：顺序建立链表 (20 分) 输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。 输入格式: 第一行输入整数的个数N(1 <= N <= 100000)。 第二行依次输入每个整数。 输出格式: 输出这组整数。 输入样例: 8 12 56 4 6 55 15 33 62 输出样例: 12 56 4 6 55 15 33 62 #include<stdio.h> #include<stdlib.
SDUT 2118-数据结构实验之链表三：链表的逆置
ccccvvvvvcv的博客
03-18 153
#include <bits/stdc++.h> using namespace std; struct node { int data; struct node *next; }; int main() { struct node *head,*p; head=(struct node *)malloc(sizeof(struct node)); ...
SDUT---数据结构---链表部分题目
ccccvvvvvcv的博客
04-01 207
数据结构实验之链表一：顺序建立链表 #include <bits/stdc++.h> using namespace std; struct yyh { int data; struct yyh* next; }*head,*p,*tail; int main() { int n; scanf("%d",&n); head=new struct yyh(); head->next=NULL; tail=head; f
【实验2 选择结构】7-8 sdut-C语言实验- 相加和最大值
weixin_73751948的博客
10-22 463
7-8 sdut-C语言实验- 相加和最大值分数 10全屏浏览题目切换布局作者 马新娟单位 山东理工大学输入三个整数a,b,c。并进行两两相加，最后比较相加和的最大值。
SDUT数据结构实验之链表三：链表的逆置
weixin_43851332的博客
05-18 594
数据结构实验之链表三：链表的逆置 Description 输入多个整数，以-1作为结束标志，顺序建立一个带头结点的单链表，之后对该单链表的数据进行逆置，并输出逆置后的单链表数据。 Input 输入多个整数，以-1作为结束标志。 Output 输出逆置后的单链表数据。 Sample Input 12 56 4 6 55 15 33 62 -1 Output 62 33 15 55 6 4 56 12 Hint 不得使用数组。 #include <iostream> #include <bit
7-210 sdut-C语言实验-小树快长高
-
10-24 842
小明每天都给小树浇水，盼望着小树快快长高。他知道小树现在有 n cm，每天长高k cm，他想知道多少天小树可以长到m cm。
数据结构_2.2、顺序表插入删除查找
cfy2401926342的博客
09-29 395
线性表：是具有相同数据类型的n （n≥0）个数据元素的有限序列顺序表：用顺序存储的方式实现线性表顺序存储：把逻辑上相邻的元素存储在物理 位置上也相邻的存储单元中，元素之间的关 系由存储单元的邻接关系来体现。ElemType ：就是你的顺序表中存放的数据元素类型。
数据结构（栈和队列的实现）
2301_80475151的博客
09-30 1121
这里介绍了栈的实现和队列的实现，还有栈和队列的OJ题例如用栈实现队列和用队列实现栈等‘；
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 303
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
排序算法之归并排序
最新发布
qq_64039411的博客
10-01 483
需要注意的是，在实际应用中，归并排序的空间复杂度较高，需要额外的空间来存储临时数组。如果对空间复杂度有要求，可以考虑使用其他排序算法。归并排序是一种分治算法，它将一个数组分成两个子数组，然后递归地对子数组进行排序，最后将两个有序的子数组合并成一个有序的数组。归并排序的时间复杂度是O(nlogn)，其中n是数组的长度。它是一种稳定的排序算法，适用于各种数据类型的排序。合并排序的关键在于合并操作。
sdut数据结构pta
11-10
SDUT数据结构PTA是山东理工大学开设的数据结构在线测评系统，旨在帮助学生更好地掌握数据结构的知识和应用。该系统包含多个题目，涵盖了数据结构的各个方面，例如链表、栈、队列、树、图等。学生可以通过该系统进行在线练习和测试，以检验自己的掌握程度和提高自己的编程能力。 如果您想了解更多关于SDUT数据结构PTA的信息，可以访问该系统的官方网站：http://acm.sdut.edu.cn/onlinejudge2/。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值