sdut 程序设计二 链表题目汇总(c语言)

已于 2022-05-27 20:32:08 修改
阅读量855 收藏 6
点赞数 8
于 2022-04-13 21:35:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62802647/article/details/124155799
版权

c++
A - 数据结构实验之链表一：顺序建立链表
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct node
{
    int data;
    struct node *next;
};

int main()
{
    int n;
    struct node *head, *tail, *p;
    head = (struct node*)malloc(sizeof (struct node));
    tail = head;

    scanf("%d", &n);

    for (int i = 0; i < n; i ++)
    {   
        p = (struct node*)malloc(sizeof (struct node));
        scanf("%d", &p->data);

        tail->next = p;
        tail = p;
    }

    p = head->next;

    while (p)
    {
        if (p->next == NULL)
            printf("%d", p->data);
        else 
            printf("%d ", p->data);

        p = p->next;
    }
    return 0;
}
B - 数据结构实验之链表二：逆序建立链表
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct node
{
    int data;
    struct node *next;
};

int main()
{
    int n;
    struct node *head, *p;
    head = (struct node*)malloc(sizeof (struct node));
    head = NULL;

    scanf("%d", &n);

    for (int i = 0; i < n; i ++)
    {
        p = (struct node*)malloc(sizeof (struct node));
        scanf("%d", &p->data);

        p->next = head;
        head = p;
    }

    while (head)
    {
        if (head->next == NULL)
            printf("%d", head->data);
        else
            printf("%d ", head->data);

        head = head->next;
    }
    return 0;
}
数据结构实验之链表三：链表的逆置
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct node
{
    int data;
    struct node *next;
};

int main()
{
    int x;
    struct node *head, *tail, *p, *head1, *p1;
    head = (struct node*)malloc(sizeof (struct node));
    tail = head;

    while (scanf("%d", &x) && x != -1)
    {
        p = (struct node*)malloc(sizeof (struct node));
        p->data = x;
        tail->next = p;
        tail = p;
    }

    p = head->next;
    head1 = (struct node*)malloc(sizeof (struct node));
    head1 = NULL;

    while (p)
    {
        p1 = (struct node*)malloc(sizeof (struct node));
        p1->data = p->data;

        p1->next = head1;
        head1 = p1;

        p = p->next;
    }

    while (head1)
    {
        if (head1->next == NULL)
            printf("%d", head1->data);
        else
            printf("%d ", head1->data);

        head1 = head1->next;
    }
    return 0;
}
数据结构实验之链表四：有序链表的归并
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct node
{
    int data;
    struct node *next;
};

int main()
{
    int n, m;
    struct node *head1, *tail1, *p1, *head2, *tail2, *p2;
    head1 = (struct node*)malloc(sizeof (struct node));
    head2 = (struct node*)malloc(sizeof (struct node));
    tail1 = head1;
    tail2 = head2;

    scanf("%d%d", &n, &m);

    for (int i = 0; i < n; i ++)
    {
        p1 = (struct node*)malloc(sizeof (struct node));
        scanf("%d", &p1->data);
        tail1->next = p1;
        tail1 = p1;
    }

    for (int i = 0; i < m; i ++)
    {
        p2 = (struct node*)malloc(sizeof (struct node));
        scanf("%d", &p2->data);

        tail2->next = p2;
        tail2 = p2;
    }

    p1 = head1->next;
    p2 = head2->next;

    while (p1 != NULL && p2 != NULL)
    {
        if ((p1->data) < (p2->data))
        {
            printf("%d ", p1->data);
            p1 = p1->next;
        }
        else
        {
            printf("%d ", p2->data);
            p2 = p2->next;
        }
    }

    while (p1 != NULL)
    {
        if (p1->next == NULL)
            printf("%d", p1->data);
        else
            printf("%d ", p1->data);
        
        p1 = p1->next;
    }

    while (p2 != NULL)
    {
        if (p2->next == NULL)
            printf("%d", p2->data);
        else
            printf("%d ", p2->data);
        
        p2 = p2->next;
    }
    return 0;
}
数据结构实验之链表五：单链表的拆分
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct node
{
    int data;
    struct node *next;
};

int main()
{
    int n;
    struct node *head, *tail, *p, *head1, *tail1, *p1, *head2, *tail2, *p2;
    head = (struct node*)malloc(sizeof (struct node));
    head1 = (struct node*)malloc(sizeof (struct node));
    head2 = (struct node*)malloc(sizeof (struct node));
    
    tail = head;
    tail1 = head1;
    tail2 = head2;
    
    scanf("%d", &n);
    
    int sum1 = 0, sum2 = 0;  //sum1 记录奇数，sum2记录偶数
    for (int i = 0; i < n; i ++)
    {
        p = (struct node*)malloc(sizeof (struct node));
        scanf("%d", &p->data);
        
        if (p->data & 1)
            sum1 ++;
        else
            sum2 ++;
        
        tail->next = p;
        tail = p;
    }
    
    printf("%d %d\n", sum2, sum1);
    
    p = head->next;
    
    while (p)
    {
        if (!(p->data & 1))
        {
            sum2 --;
            
            if (sum2 == 0)
                printf("%d\n", p->data);
            else
                printf("%d ", p->data);
        }
        
        p = p->next;
    }
    
    p = head->next;
    
    while (p)
    {
        if (p->data & 1)
        {
            sum1 --;
            
            if (sum1 == 0)
                printf("%d\n", p->data);
            else
                printf("%d ", p->data);
        }
        
        p = p->next;
    }
    return 0;
}
数据结构实验之链表七：单链表中重复元素的删除
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct node
{
    int data;
    struct node *next;
};

int main()
{
    int n;
    struct node *head, *tail, *p;
    
    head = (struct node*)malloc(sizeof (struct node));
    head->next = NULL;
    
    scanf("%d", &n);
    
    for (int i = 0; i < n; i ++)
    {
        p = (struct node*)malloc(sizeof (struct node));
        scanf("%d", &p->data);
        
        p->next = head->next;
        head->next = p;
    }
    
    printf("%d\n", n);
    
    p = head->next;
    while (p)
    {
        if (p->next == NULL)
            printf("%d\n", p->data);
        else
            printf("%d ", p->data);
        
        p = p->next;
    }
    
    p = head->next;
    struct node *q, *g;
    while (p)
    {
        g = p;
        q = p->next;
        while (q)
        {
            if (q->data == p->data)
            {
                n --;
                g->next = q->next;
                free(q);
                q = g->next;
            }
            else
            {
                g = q;
                q = q->next;
            }
        }
        
        p = p->next;
    }
    
    printf("%d\n", n);
    
    p = head->next;
    while (p)
    {
        if (p->next == NULL)
            printf("%d\n", p->data);
        else
            printf("%d ", p->data);
        
        p = p->next;
    }
    return 0;
}
师–链表的结点插入
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct node
{
    int data;
    struct node *next;
};

int main()
{
    int n;
    while (~scanf("%d", &n))
    {
        struct node *head, *tail, *p;
        head = (struct node*)malloc(sizeof (struct node));
        tail = head;
        
        for (int i = 0; i < n; i ++)
        {
            tail = head;
            p = (struct node*)malloc(sizeof (struct node));
            int m;
            
            scanf("%d%d", &m, &p->data);
            while (m -- && tail->next)
            {
                tail = tail->next;
            }
            
            p->next = tail->next;
            tail->next = p;
        }
        
        p = head->next;
        while (p)
        {
            if (p->next == NULL)
                printf("%d\n", p->data);
            else
                printf("%d ", p->data);
            
            p = p->next;
        }
    }
    return 0;
}
约瑟夫问题
#include <stdio.h>

struct node {
    int data;
    struct node* next;
};

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    struct node *tail, *head, *p, *q;
    head = (struct node*)malloc(sizeof(struct node));
    
    head->next = NULL;
    tail = head;
    
    for (int i = 1; i <= n; i ++)
    {
        p = (struct node*)malloc(sizeof(struct node));
        p->data = i;
        tail->next = p;
        tail = p;
    }
    p->next = head->next;
    
    p = head->next;
    while (p->next != p)
    {
        int k = m;
        while (k > 1) {
            q = p;
            p = p->next;
        }
        
        q->next = p->next;
        free(p);
        p = q->next;
    }
    
    printf("%d", p->data);
    return 0;
}
不敢死队问题
#include <stdio.h>

struct node {
    int data;
    struct node* next;
};

int main()
{
    int n, m, ans = 0;
    while (~scanf("%d", &n) && n)
    {
        ans = 0;
        struct node *tail, *head, *p, *q;
        head = (struct node*)malloc(sizeof(struct node));
        head->next = NULL;
        tail = head;

        for (int i = 1; i <= n; i ++)
        {
            p = (struct node*)malloc(sizeof(struct node));
            p->data = i;
            tail->next = p;
            tail = p;
        }
        p->next = head->next;

        p = head->next;
        while (p->next != p) 
        {
            int k = 5;
            while (k -- > 1)
            {
                q = p;
                p = p->next;
            }

            if (p->data == 1) break;
            q->next = p->next;
            free(p);
            p = q->next;
            ans ++;
        }

        printf("%d\n", ans + 1);
    }
    return 0;
}
数据结构实验之链表九：双向链表
#include <stdio.h>

typedef struct node
{
    int data;
    struct node *pre, *next;
};

int main()
{
    int n,m,i;
    scanf("%d%d", &n, &m);
    struct node *head, *tail, *p;
    head = (struct node*)malloc(sizeof (struct node));
    head->next = NULL;
    tail = head;
    
    for (int a=0; a<n; a++)
    {
        p = (struct node*)malloc(sizeof (struct node));
        scanf("%d", &p->data);
        p->pre = tail;
        tail->next = p;
        tail = p;
    }
    
    while (m --)
    {
        scanf("%d", &i);
        p = (struct node*)malloc(sizeof (struct node));
        p = head->next;
        
        while (p)
        {
            if(p->data == i) break;
            p = p->next;
        }
        
        if (p->next != NULL && p->pre != head)
            printf("%d %d\n", p->pre->data, p->next->data);
        else if (p->pre!=head)
            printf("%d\n", p->pre->data);
        else
            printf("%d\n", p->next->data);
    }
    return 0;
}
WDLieqi
关注
SDUT 《程序设计基础I 》实验2-选择结构程序 知识点+题目详解
m0_72900498的博客
11-07 501
SDUT 《程序设计基础I 》实验2-选择结构程序 设计题解 && c语言语法讲解（一题多解）
SDUT ACM 数据结构实验之链表二：逆序建立链表（基于C语言）
CHEN_ZAN_YU的博客
05-12 301
数据结构实验之链表二：逆序建立链表Time Limit: 1000 ms Memory Limit: 65536 KiBSubmit StatisticProblem Description输入整数个数N，再输入N个整数，按照这些整数输入的相反顺序建立单链表，并依次遍历输出单链表的数据。Input第一行输入整数N;；第二行依次输入N个整数，逆序建立单链表。Output依次输出单链表所存放的数据。S...
自己写的c程序，链表的所有操作都有
10-19
很适合练手的一点程序，都是自己写的，包括数据结构的部分知识，链表
SDUT 《程序设计基础（B）II》实验2--链表
sdut_you的博客
06-08 323
2019级《程序设计基础（B）II》实验2–链表 https://acm.sdut.edu.cn/onlinejudge3/contests/3193/overview A - 数据结构实验之链表一：顺序建立链表 #include <stdio.h> #include <stdlib.h> #include <string.h> struct node { int data; struct node *next; }; int main() { s
SDUT 2019 级程序设计基础（B）II 实验2--链表
Here_SDUT的博客
06-03 799
快期末了 好久没用过C，重新打一下程设二的内容找找手感，顺便水几篇博客，简单题直接过，需要思考的会有注释或者思路，重要知识点会总结，祝大家期末都AK！！！ 总题目链接 2-1数据结构实验之链表一：顺序建立链表 #include <stdio.h> #include <stdlib.h> typedef struct//使用typedef后，之后定义该类型结构体不用写struct node p，直接node p即可，后面不解释 { int data; struct n
链表操作 基本程序
diefengyi2249的博客
07-24 129
（1）向后插入元素 void insert_tail(link p){ link q = NULL; if(NULL == head)//判断head是否为空 { head = p;//head为空则直接赋值 return; } //head不为空 //则遍历链表，直至最后一个节点 for(q = head; q-&...
链表笔试题C语言计算机二级,2016下半年计算机考试二级C笔试试题（文字版）
weixin_36287955的博客
05-20 284
2016下半年计算机考试二级C笔试试题(文字版)一、选择题(1)下列叙述中正确的是A)对长度为 n的有序链表进行查找，最坏清况下需要的比较次数为 nB)对长度为 n的有序链表进行对分查找，最坏情况下需要的比较次数为 (n/2)C)对长度为 n的有序链表进行对分查找，最坏情况下需要的比较次数为 (log2n)D)对长度为 n的有序链表进行对分查找，最坏情况下需要的比较次数为 (nlog2n)(2)算...
SDUT ACM数据结构实验之链表九：双向链表（基于C语言）
CHEN_ZAN_YU的博客
05-28 270
数据结构实验之链表九：双向链表Time Limit: 1000 ms Memory Limit: 65536 KiBSubmit Statistic DiscussProblem Description学会了单向链表，我们又多了一种解决问题的能力，单链表利用一个指针就能在内存中找到下一个位置，这是一个不会轻易断裂的链。但单链表有一个弱点——不能回指。比如在链表中有两个节点A,B，他们的关系是B是A...
SDUT小C语言--词法分析程序(C语言版)
qq_47969743的博客
09-20 243
小C语言文法 1. <程序>→<main关键字>(){<声明序列><语句序列>} 2. <声明序列>→<声明序列><声明语句>|<声明语句>|<空> 3. <声明语句>→<标识符表>; 4. <标识符表>→<标识符>,<标识符表>|<标识符> 5. <语句序列>→<语句序列><语句>|<.
SDUT 实训 超市库存管理系统 C语言
weixin_48135986的博客
07-11 1637
#include <stdio.h> #include <stdlib.h> #define _CRT_SECURE_NO_WARNINGS struct Goods { int code; char name[20]; char origin[20]; int count; double price; }; char chose; void menu(); void setcolor(); void addGoods(); void lis
C++链表完整程序，功能强大
11-15
C++链表完整程序 使用模板编写代码 包含删除元素、添加元素、搜索元素、输出元素处理
一个c++链表完整例子
09-29
一个c++链表完整例子，包括了有关于链表的所有基本操作的实现，简单易懂！
整数链表 的程序 有题目和答案
04-23
实现整数链表的建立，其中还有复制链表的过程
链表操作程序—C语言
12-15
链表的操作，链表的加入、删除、合并操作
计算机二级c语言链表大题,计算机等级考试二级C语言链表复习专题
weixin_35709128的博客
05-27 980
四、循环链表循环链表是与单链表一样，是一种链式的存储结构，所不同的是，循环链表的最后一个结点的指针是指向该循环链表的第一个结点或者表头结点，从而构成一个环形的链。循环链表的运算与单链表的运算基本一致。所不同的有以下几点：1、在建立一个循环链表时，必须使其最后一个结点的指针指向表头结点，而不是象单链表那样置为NULL。此种情况还使用于在最后一个结点后插入一个新的结点。2、在判断是否到表尾时，是判断该...
C程序设计--习题--链表
YuyaoMINE的博客
05-02 318
判断输出结果 在做练习的时候遇见的一道题，蒙了很长时间搞不懂其中的门道，大脑突然死机，哈哈。还好最后清楚了。 #include <stdio.h> #include <stdlib.h> void main() { struct node{ int x; struct node *next; }*p1,*p2=NULL; int a[5]={7,6,-5,28...
链表类编程题
qq_43003252的博客
07-10 361
1.从尾到头打印链表 输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。 思路：(1)利用栈先入后出的特性完成; (2）第二就是存下来然后进行数组翻转。 （3）利用递归。 代码： //利用c++中自带的翻转函数reverse实现 class Solution { public: vector<int> printListFromTailToHead(ListNode* head) { vector<int> value; Lis
c语言链表考试题,二级C语言考试必备(真题)考点42 链表.doc
weixin_36221941的博客
05-19 425
二级C语言考试必备(真题)考点42 链表.doc下载提示(请认真阅读)1.请仔细阅读文档，确保文档完整性，对于不预览、不比对内容而直接下载带来的问题本站不予受理。2.下载的文档，不会出现我们的网址水印。3、该文档所得收入(下载+内容+预览)归上传者、原创作者；如果您是本文档原作者，请点此认领！既往收益都归您。文档包含非法信息？点此举报后获取现金奖励！下载文档到电脑，查找使用更方便20积分还剩页未读...
单链表编程题
saizo123的博客
03-06 934
算法思想：使用两个指针first和second，只是first每次走一步，second每次走两步：static Link GetMiddleOne(Link head) { Link first = head; Link second = head; while (first != null && first.Next != null) { first = first.Next.Next; seco
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值