上机二——单链表

最新推荐文章于 2024-01-29 14:47:40 发布
最新推荐文章于 2024-01-29 14:47:40 发布
阅读量101 收藏
点赞数 3
文章标签： 算法 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75017568/article/details/134232509
版权

1.创建有序单链表

【问题描述】为从键盘终端输入的m个整数创建带头结点的有序单链表存储结构，使输入的数据元素在单链表中按照元素值递增有序。

【输入形式】

第一行：单链表中元素个数m

第二行：单链表中的m个整数

【输出形式】

按递增有序形式输出m个整数

【样例输入】

5

1 3 2 4 5

【样例输出】

1 2 3 4 5

【样例说明】

【评分标准】

#include <iostream>
using namespace std;
struct Node {
    int data;
    Node *next;
};
typedef Node *LinkList;
void createOList(LinkList &L,int m)
{
    int num,i=0,s[m];
    while(cin>>num)
    {
        s[i++]=num;
    }
    for(int i=0;i<m-1;i++)
    {
        for(int j=i+1;j<m;j++)
        {
            if(s[i]>s[j])
            {
                int t=0;
                t=s[i];
                s[i]=s[j];
                s[j]=t;
            }
        }
    }

    Node  *p,*r;
    L=new  Node;
    L->next=NULL;
    r=L;
    i=0;
    while(m)
    {
        p=new  Node;
        p->data=s[i++];
        r->next=p;
        r=p;
        m--;
    }
    r->next=NULL;
}
void printList(LinkList L) {
    Node *p;
    p=L->next;
    while(p) {
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}
int main() {
    LinkList L;
    int m;
    cin>>m;//单链表中元素个数
    createOList(L,m);//创建带头节点的有序单链表
    printList(L);
    return 0;
}

2.输出单链表中的数据并统计单链表中的元素个数

【问题描述】下面程序中createList函数的功能是创建若干个整数的带头结点的单链表存储结构。getLength函数的功能是求解单链表中元素的个数，printLst函数的功能是将单链表中各个整数以空格间隔顺序输出。根据上下文，将程序补充完整。

【输入形式】若干整数以空格间隔

【输出形式】两行。第一行：单链表中的整数以空格间隔输出；第二行：单链表中元素的个数

【样例输入】1 2 3 4 5

【样例输出】

1 2 3 4 5

5

【样例说明】

【评分标准】

#include <iostream>
#include <cstdlib>
using namespace std;
struct LNode
{
    int data;
    LNode *next;
};
void createList(LNode *&h)
{
    int num;
    LNode *p,*r;
    h=new LNode;
    h->next=NULL;
    r=h;
    while(cin>>num)
    {
        p=new LNode;
        p->data=num;
        r->next=p;
        r=p;
    }
    r->next=NULL;
}

int  getLength(LNode *&L)
{
        LNode  *p;
        int length=0;
        p=L->next;
        while(p)  {
                p=p->next;
                length++;
        }
        return length;
}
void printList(LNode *&L)
{
    LNode  *p;
        p=L->next;
        while(p)  {
                cout<<p->data<<" ";
                p=p->next;
        }
        cout<<endl;
}

int main()
{
    LNode *L;
    createList(L);
    printList(L);
    cout<<getLength(L);
    return 0;
}

3.删除单链表中相同元素

【问题描述】单链表中存放了若干整数，请删除相同整数。

【输入形式】单链表

【输出形式】删除相同整数后的单链表

【样例输入】1 1 1 2 3

【样例输出】1 2 3

【样例说明】以递增的形式输入数据，允许相同元素

【评分标准】

#include <stdlib.h>
#include <iostream>
using namespace std;
//类型定义
#include <stdlib.h>
struct LNode
{
    int data;
    LNode *next;
};
typedef LNode *LinkList;

//尾插入法创建单链表
void createList(LinkList &h, int n)
{
    h = new LNode;
    h->next = NULL;
    LNode *p, *r;
    r = h;
    for (int i = 1; i <= n; i++)
    {
        p = new LNode;
        cin>>p->data;
        r->next = p;
        r = p;
    }
    r->next = NULL;
}
void printList(LinkList h)
{
    LNode *p=h->next;
    while(p)
    {
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}

void listDeleteRepeat(LinkList h)
{
    LNode *p=h->next;
    while(p)
    {
        LNode *q=p;
        while(q->next)
        {
            if(q->next->data==p->data)
            {
                LNode *tmp=q->next;
                q->next=q->next->next;
                delete tmp;
            }
            else{
                q=q->next;
            }
        }
        p=p->next;
    }
}

int main()
{
    LinkList h;
    createList(h, 5);
    listDeleteRepeat(h);
    printList(h);
    return 0;
}

4.删除单链表中某区间的数

【问题描述】已知某带头结点的单链表中存放着若干整数，请删除该单链表中元素在[x, y]之间的所有结点，要求算法的时间复杂度为O(n)，空间复杂度为O(1)。

【输入形式】第一行：单链表中元素个数m

第二行：单链表中的m个整数

第三行：要删除的元素值所在区间[x,y]对应的x和y

【输出形式】

删除元素后的单链表中剩下的元素值

【样例输入】

5

13 24 50 33 56

30 50

【样例输出】

13 24 56

【样例说明】

【评分标准】

#include <iostream>
using namespace std;
struct Node {
    int data;
    Node *next;
};
typedef Node *LinkList;
void createList(LinkList &L,int n) {
    Node *p,*r;
    L=new Node;
    L->next=NULL;
    r=L;
    for(int i=1; i<=n; i++) {
        p=new Node;
        cin>>p->data;
        r->next=p;
        r=p;
    }
    r->next=NULL;
}
void printList(LinkList L) {
    Node *p;
    p=L->next;
    while(p) {
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}
void delElem(LinkList h,int a,int b)
{
    Node *p,*c;
    p=h,c=h->next;//c为p的下一个结点
    while(c)
    {
        if(c->data>=a&&c->data<=b)
        {
            p->next=c->next;
            delete c;
            c=p->next;
        }
        else
        {
            p=p->next;
            c=c->next;
        }
    }
}
int main() {
    LinkList L;
    int m;
    int x,y;
    cin>>m;//单链表中元素个数
    createList(L,m);//尾插入法创建带头节点的单链表
    cin>>x>>y;//要删除的元素值所在区间[x,y],包含x和y
    delElem(L,x,y);//删除单链表中x-y之间的数
    printList(L);//输出结果单链表中的所有数据
    return 0;
}

5.倒数第k个元素

【问题描述】已知带头结点的非空单链表中存放着若干整数，请找出该链表中倒数第k个元素。

【输入形式】第一行：单链表中元素个数m

第二行：单链表中的m个整数

第三行：k值

【输出形式】倒数第k个元素的值（不存在倒数第k个元素输出"no"）

【样例输入】

5

13 24 50 33 56

2

【样例输出】

33

【样例说明】

输入：

5

13 24 50 33 56

6

输出：no

【评分标准】

#include <iostream>
using namespace std;
struct Node {
    int data;
    Node *next;
};
typedef Node *LinkList;
void createList(LinkList &L,int n) {
    Node *p,*r;
    L=new Node;
    L->next=NULL;
    r=L;
    for(int i=1; i<=n; i++) {
        p=new Node;
        cin>>p->data;
        r->next=p;
        r=p;
    }
    r->next=NULL;
}
void printList(LinkList L) {
    Node *p;
    p=L->next;
    while(p) {
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}
Node *getElem(LinkList L,int k)
{
    int count=0;
    Node *p,*a;
    p=L->next;//p指向第二个结点
    a=L->next;
    while(p)
    {
        if(count<k)
            count++;
        else
            a=a->next;
        p=p->next;
    }
    if(count==k)
        return a;
    else
        return 0;
}
int main() {
    LinkList L;
    int m,k;
    cin>>m;//单链表中元素个数
    createList(L,m);//尾插入法创建带头节点的单链表
    cin>>k;
    Node *p=getElem(L,k);//找单链表中倒数第k个元素
    if(p)
        cout<<p->data;
    else
        cout<<"no";
    return 0;
}

6.查找两个单链表的公共结点

【问题描述】给定两个单链表，编写算法找出两个链表的公共结点

【输入形式】用于构造两个公共链表的结点数和数据元素的值

【输出形式】两个单链表所有公共结点的元素值以空格间隔输出

【样例输入】若构建的两个链表结构如下图所示：则公共结点为数据值为11和15的结点。

【样例输出】11 15

【样例说明】

【评分标准】

#include <iostream>
#include <ctime>
#include <cstdlib>
using namespace std;
struct LNode
{
    int data;
    LNode *next;
};
typedef LNode *Linklist;
void create(Linklist &h,int n)
{
    LNode *r,*p;
    h=new LNode;
    h->next=NULL;
    r=h;
    for(int i=1; i<=n; i++)
    {
        p=new LNode;
        cin>>p->data;
        r->next=p;
        r=p;
    }
    r->next=NULL;
}

void create(Linklist &h)
{
    LNode *r,*p;
    srand(time(NULL));
    int i,m;
    m=rand()%10;
    h=new LNode;
    h->next=NULL;
    r=h;
    for(int i=1; i<=m; i++)
    {
        p=new LNode;
        p->data=rand()%90+10;
        r->next=p;
        r=p;
    }
    r->next=NULL;
}


LNode *getTail(Linklist h)
{
    LNode *tail;
    tail=h;
    while(tail->next)
    {
        tail=tail->next;
    }
    return tail;
}

void connect(Linklist ha,Linklist hb)
{
    LNode *r;
    r=getTail(ha);
    r->next=hb->next;
}

void printList(Linklist h)
{
    LNode *p=h->next;
    while(p)
    {
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}

void printPublicNode(Linklist ha, Linklist hb)
{
    LNode *pa = ha->next;
    while (pa)
    {
        LNode *pb = hb->next;
        while (pb)
        {
            if (pa == pb)
            {
                cout << pa->data << " ";
                break;
            }
            pb = pb->next;
        }
        pa = pa->next;
    }

}


int main()
{
    Linklist ha,hb,hc;
    int n;
    cin>>n;
    create(ha);
    create(hb);
    create(hc,n);
    connect(ha,hc);
    connect(hb,hc);
    printPublicNode(ha,hb);
    return 0;
}

7.有序集合的并集-无重复数据-单链表

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

【输入形式】三行，第一行：两个有序链表中元素的个数，第二行：第一个链表中的元素以空格间隔，第三行：第二个链表中的元素以空格间隔

【输出形式】合并后的没有重复元素的有序链表中的数据以空格间隔

【样例输入】

3 4

1 5 7

2 4 7 9

【样例输出】1 2 4 5 7 9

【样例说明】

【评分标准】

#include <bits/stdc++.h>
using namespace std;
struct OLNode
{
    int data;
    OLNode *next;
};
typedef OLNode *OLinkList;
OLNode *getPre(OLinkList h,int e)
{
    OLNode *pre=h;
    while(pre->next&&pre->next->data<e)
        pre=pre->next;
    return pre;
}
void createOLinkList(OLinkList &h,int n)
{
    h=new OLNode;
    h->next=NULL;
    OLNode *pre,*p;
    int e;
    for(int i=1; i<=n; i++)
    {
        cin>>e;
        p=new OLNode;
        p->data=e;
        pre=getPre(h,e);
        p->next=pre->next;
        pre->next=p;
    }
}
void printOLinkList(OLinkList h)
{
    OLNode *p;
    p=h->next;
    while(p)
    {
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}
void olistUnion(OLinkList ha, OLinkList hb)
{
    OLinkList h = ha;
    OLinkList p = ha->next;
    OLinkList q = hb->next;
    while (p && q) {
        if (p->data < q->data) {
            h->next = p;
            h = p;
            p = p->next;
        }
        else if (p->data > q->data) {
            h->next = q;
            h = q;
            q = q->next;
        }
        else {
            // 两个节点的数据相等，保留一个节点并删除另一个节点
            h->next = p;
            h = p;
            p = p->next;
            OLinkList tmp = q->next;
            delete q;
            q = tmp;
        }
    }
    h->next = p ? p : q;    // 将剩余部分接入新链表
    delete hb;   // 释放链表hb的头结点
}

int main()
{
    int m,n;
    OLinkList ha,hb;
    cin>>m>>n;
    createOLinkList(ha,m);
    createOLinkList(hb,n);
    olistUnion(ha,hb);
    printOLinkList(ha);
    return 0;
}

8.有序集合的并集-单链表

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

【输入形式】三行，第一行：两个有序链表中元素的个数，第二行：第一个链表中的元素以空格间隔，第三行：第二个链表中的元素以空格间隔

【输出形式】合并后的没有重复元素的有序链表中的数据以空格间隔

【样例输入】

3 4

1 5 7

2 4 7 9

【样例输出】1 2 4 5 7 7 9

【样例说明】

【评分标准】

#include <bits/stdc++.h>
using namespace std;
struct OLNode
{
    int data;
    OLNode *next;
};
typedef OLNode *OLinkList;
OLNode *getPre(OLinkList h,int e)
{
    OLNode *pre=h;
    while(pre->next&&pre->next->data<e)
        pre=pre->next;
    return pre;
}
void createOLinkList(OLinkList &h,int n)
{
    h=new OLNode;
    h->next=NULL;
    OLNode *pre,*p;
    int e;
    for(int i=1; i<=n; i++)
    {
        cin>>e;
        p=new OLNode;
        p->data=e;
        pre=getPre(h,e);
        p->next=pre->next;
        pre->next=p;
    }
}
void printOLinkList(OLinkList h)
{
    OLNode *p;
    p=h->next;
    while(p)
    {
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}
void olistUnion(OLinkList ha, OLinkList hb)
{
    OLinkList h = ha;
    OLinkList p = ha->next;
    OLinkList q = hb->next;
    while (p && q) {
        if (p->data <= q->data) {
            h->next = p;
            h = p;
            p = p->next;
        }
        else if (p->data > q->data) {
            h->next = q;
            h = q;
            q = q->next;
        }
        
    }
    h->next = p ? p : q;    // 将剩余部分接入新链表
    delete hb;   // 释放链表hb的头结点
}
int main()
{
    int m,n;
    OLinkList ha,hb;
    cin>>m>>n;
    createOLinkList(ha,m);
    createOLinkList(hb,n);
    olistUnion(ha,hb);
    printOLinkList(ha);
    return 0;
}

swoows
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构c语言版单链表的创建和输出
06-08
（1）键盘输入n，建立长度为n的单链表并输出； （2）键盘输入x。在单链表中查找值为x的结点并删除，最后输出链表。
输出一个有序单链表
weixin_44588315的博客
06-28 941
一、单链表 单链表，就是线性表的链式存储结构，又称线性链表。 它的特点是：用一组任意的存储单元存储线性表的数据元素，即结点之间在逻辑上是连续的，在物理上是不连续的。 单链表是带有头结点的，头节点只起到“哨兵”的作用，它的数据域是不使用的，指针域指向第一个数据域的位置。 以下代码是单链表各个结点的逻辑表示：data是节点的数据域，next是指针域——存储下一个结点的地址。 struct list ...
输出单链表c语言代码,用C语言实现单链表的各种操作
weixin_35473679的博客
05-21 2407
2013本篇文章是对用C语言实现单链表的各种操作进行了详细的分析介绍，需要的朋友参考下最近，从新复习了一下数据结构中比较重要的几个部分，现在把自己的成果记录下来，主要就是仿照严蔚敏的《数据结构》(C 语言版)，中的例子和后面的习题进行改编的。首先，是单链表的各种实现，其中，包含了一些常考的知识点。例如，单链表的逆置，单链表的合并，找到单链表的中间节点等的算法实现。下面这个是单链表的结构体的定义：t...
创建一个单链表，并输出单链表（C++）
t18438605018的博客
09-14 7200
1.题目要求 创建一个带头结点的单链表，并打印输出链表的值 分析：首先要搞清楚什么是头结点，正常情况下一个单链表是不带头结点的。为了对单链表插入或删除操作的方便，特意引入了头结点。头结点指向链表中第一个结点。 如图所示，展示了“不带头结点的单链表”和“带头结点的单链表”。两者比较，“带头结点的单链表”实际上就在“不带头结点的单链表”前增加了一个结点。这个可以有数据域（比如存储表长等），也可以数据域中不存储东西，但它的指针域一定指向单链表的第一个元素。 2.代码 #include<iostream&g
数据结构——单链表的输出——我的学习之路
qq_43923446的博客
04-17 4031
#include using namespace std; typedef struct node{ int data; struct node *next; }node,*linklist; node *Create()//链表创建函数 { linklist head,p,tail; cout<<“请输入链表数据，以0结束！！！”<<endl; head=p=tail=n...
数据结构实验——单链表
02-12
1、掌握用Visual C++6.0上机调试单链表的基本方法 2、掌握单链表的插入、删除、查找、求表长以及有序单链表的合并算法的实现 二、实现内容 1、单链表基本操作的实现 在带头结点的单链表h中第i个数据元素之前插入一个...
C++与数据结构 第一次上机实验——线性表.pdf
11-07
实验内容涉及对单链表的操作，包括删除指定值节点的直接前驱节点和求两个递增链表的交集。对于删除操作，首先通过循环找到目标节点的前一个节点，然后调整链表连接以删除目标节点。对于求交集，需要遍历两个链表，将...
C++与数据结构 第一次上机实验——线性表.docx
11-07
2. **求两个有序链表的交集**：对于两个已排序的单链表 `LA` 和 `LB`，求它们的交集 `C`，可以通过同时遍历两个链表，比较当前节点的值，当值相等时，将该值加入结果链表。在实验中，可能需要设计一个新的算法来实现...
单链表操作实验报告.doc
12-22
3. 掌握线性表的链式存储结构——单链表的定义及其 C 语言实现。 4. 掌握线性表在顺序存储结构即顺序表中的各种基本操作。 5. 掌握线性表在链式存储结构——单链表中的各种基本操作。 二、实验要求 1. 认真阅读与...
2、上机实验报告二栈与队列.docx
03-16
在本实验报告中，主要涉及了两个核心的数据结构——栈（Stack）和队列（Queue），以及它们在实际问题中的应用。首先，我们来看栈和队列的基本概念和操作。 栈是一种后进先出（Last In First Out, LIFO）的数据结构...
创建单链表并输出单链表
图灵动力的博客
07-19 5869
创建一个单链表并输出单链表 ①基本思路： 定义一个结构体，包含数据域和指针域，前者为该结点保存的用户数据，后者为该结点保存的下一个相邻结点的地址。 定义一个结点创建函数(返回head)，用head指向第一个结点、p1开辟新节点、p2连接新节点。 定义一个结点输出函数，用do…while形式依次打印出每一个结构体成员数据域。 在main()函数中，依次调用上述函数。 ②源代码： /* 创建一个单链表，每个结点包含三个元素，学生编号、分数、保存下一个节点地址的指针 */ #include <stdio
单链表的建立与输出
Jason
12-05 2338
1 #include 2 #include 3 #define LEN sizeof(struct node) 4 typedef struct node* Node; 5 struct node 6 { 7 int num; 8 struct node *next; 9 }; 10 11 int n = 0; 12 //创建单链表 13
单链表创建和输出（简单使用）
Miraitowup的博客
01-27 6635
单链表创建和输出（简单使用） 代码实现 #include<stdio.h> typedef struct Lnode{ int data; struct Lnode*next; }Lnode,*LinkList; //尾插法 void Greate(LinkList &L,int n) { L=new Lnode; //创建头节点 L->next=NULL; LinkList r; r=L; printf("请依次输入各元素\n"); for(int i
【C语言】单链表的初始化，创建和输出
m0_60511809的博客
11-20 6995
链表主要分为四种：单向链表，双向链表，单向循环链表，双向循环链表。这里的单链表默认为单项非循环链表。 要确定一个数组，需要知道两个参数，一个是数组名，即数组首元素地址，另一个是数组元素个数。而要确定一个单链表，只需要知道头指针，因为头指针指向头结点，头结点存放首结点的地址，首结点存放下一个结点的地址，······，直到最后一个结点。 所以单链表的初始化就是创建一个头指针，指向头结点，而头结点的指针域为空，表示空单链表。 单链表的创建可以分...
单链表的实现代码
m0_51469347的博客
10-06 770
#define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include <stdlib.h> #include <time.h> // 定义 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int Status; typedef int ElemType; // 定义结点结构 typedef struct Node {
头插法进行单链表的创建并输出随机数
joie_de_的博客
12-06 528
这里用头插法进行链表的创建 千万不要忘记初始化链表，不然有可能会出错 #include<stdio.h> #include<stdlib.h> #include<time.h> typedef struct LNode { int data; struct LNode *next; } Link,*LinkList; //初始化单链表 int InitList(LinkList *L) { *L = (LinkList)malloc(sizeof(L...
单链表中的基本操作(详细代码图解+注释+算法步骤)
Xiao_Ya__的博客
05-23 6874
单链表中的基本操作(详细代码图解+注释+算法步骤)
单链表学习总结 ---输入输出
最新发布
island1314的博客
01-29 1049
int data;//0、打印//1、正常输入输出//2、第一个数据为随机值，但是有利于结点删除//3、对于小于m的数删除//主函数int main()// 1、//2、//3、实现对小于m 的数进行的删除操作int m;p;
单链表的创建、插入、删除、查找、取值、输出、退出功能实现
naozibuok的博客
04-12 3055
④⑤是尾插法的精髓，创建很多结点再把他们头尾相连形成链表，就在于不断开辟新的p结点，给他们的数据域赋值，然后与上一个r结点相连接，最后把r结点等于新开辟的p结点。这也就是为什么要把以下四步放入循环中。
地理信息网络服务上机报告——张清昱
"地信17-1班 张清昱 071723361 - 地理信息网络服务上机报告" 这篇上机报告详细介绍了张清昱同学在地理信息科学课程中的实践操作，主要内容涉及Web服务器配置、HTML、CSS和JavaScript的应用。以下是相关知识点的详细...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值