2023实验2 链表

最新推荐文章于 2024-07-22 09:38:37 发布
最新推荐文章于 2024-07-22 09:38:37 发布
阅读量31 收藏
点赞数
分类专栏： 2023数据结构oj 文章标签： 链表 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Phoenix0427/article/details/134367977
版权

【id:81】【40分】A. DS单链表--存储结构与操作

#include<iostream>
#include<stdlib.h>
using namespace std;

class Node 
{
public:
    int data;
    Node* next;

    Node() 
    {
        next = NULL;
        data = 0;
    }
};

class linklist 
{
public:
    Node* head;
    int length;

    linklist();

    ~linklist();

    Node* CreateNode(int n);

    Node* index(int i);

    int getitem(int i);

    int listinsert(int i, int e);

    int listdelete(int i);

    void display();
};

linklist::linklist() 
{
    head = new Node();
    length = 0;
}

linklist::~linklist() 
{
    Node* p, * q;
    p = head;
    while (p != NULL) 
    {
        q = p;
        p = p->next;
        delete q;
    }
    length = 0;
    head = NULL;
}

int linklist::getitem(int i) 
{
    if (index(i)) 
        return index(i)->data;
    else return -1;
}

Node* linklist::index(int i) 
{
    int j;
    Node* p;
    p = head->next;
    j = 1;
    while (p != NULL && j < i) 
    {
        p = p->next;
        j++;
    }
    if (j != i) 
        return NULL;
    else
        return p;
}

Node* linklist::CreateNode(int n) 
{
    Node* tail = head, * s;
    int i;
    for (i = 0; i < n; i++) 
    {
        s = new Node;
        cin >> s->data;
        tail->next = s;
        tail = s;
    }
    s = NULL;
    delete s;
    length = length + n;
    return head;
}

void linklist::display() 
{
    Node* p;
    p = head->next;
    while (p) 
    {
        cout << p->data << ' ';
        p = p->next;
    }
    cout << endl;
}

int linklist::listdelete(int i) 
{
    Node* p = head, * q;
    int j=0;
    while (p->next && j < i - 1) 
    {
        p = p->next;
        j++;
    }
    if (!p->next || j > i - 1) 
        return -1;
    q = p->next;
    p->next = q->next;
    free(q);
    return 0;
}

int linklist::listinsert(int i, int item)
{
    Node* p = head, * s;
    int j = 0;
    while (p && j < i - 1) 
    {
        p = p->next;
        j++;
    }
    if (!p || j > i - 1) 
        return -1;
    s = new Node;
    s->data = item;
    s->next = p->next;
    p->next = s;
    return 0;
}

int main() 
{
    int n, i, num;
    cin >> n;
    linklist p;
    Node* head;
    head = p.CreateNode(n);
    p.display();
    cin >> i >> num;
    if (p.listinsert(i, num) == 0)
        p.display();
    else 
        cout << "error" << endl;
    cin >> i >> num;
    if (p.listinsert(i, num) == 0)
        p.display();
    else
        cout << "error" << endl;

    cin >> i;
    if (p.listdelete(i) == 0)
        p.display();
    else
        cout << "error" << endl;
    cin >> i;
    if (p.listdelete(i) == 0)
        p.display();
    else
        cout << "error" << endl;

    cin >> i;
    if (p.getitem(i) != -1)
        cout << p.getitem(i);
    else
        cout << "error" << endl;
    cin >> i;
    if (p.getitem(i) != -1) 
        cout << p.getitem(i);
    else 
        cout << "error" << endl;
}

【id:80】【20分】B. DS单链表--结点交换

#include <iostream>
#include <stdlib.h>
using namespace std;

class Node 
{
public:
    int data;
    Node* next;

    Node() 
    {
        next = NULL;
        data = 0;
    }
};

class linklist 
{
public:
    Node* head;
    int length;

    Node* listindex(int i);

    linklist();

    ~linklist();

    Node* CreateNode(int n);

    int swap(int pa, int pb);

    void display();
};

linklist::linklist()
{
    head = new Node();
    length = 0;
}

int linklist::swap(int pa, int pb)
{
    if ((pa < 1 || pa > length) || (pb < 1 || pb > length)) 
        return -1;

    Node* p, * q;
    p = new Node;
    p = listindex(pa - 1);
    q = listindex(pb - 1);

    Node* t = p->next;
    p->next = q->next;
    q->next = t;
    Node* tem = p->next->next;
    p->next->next = q->next->next;
    q->next->next = tem;
    return 0;
}

linklist::~linklist() 
{
    Node* p, * q;
    p = head;
    while (p != NULL) 
    {
        q = p;
        p = p->next;
        delete q;
    }
    length = 0;
    head = NULL;
}

Node* linklist::listindex(int i)
{
    int j=0;
    Node* p=head;
  
    while (p != NULL && j < i) 
    {
        p = p->next;
        j++;
    }
    return p;
}

Node* linklist::CreateNode(int n) 
{
    Node* tail = head, * s;
    int i;
    for (i = 0; i < n; i++) 
    {
        s = new Node;
        cin >> s->data;
        tail->next = s;
        tail = s;
    }
    s = NULL;
    delete s;
    length += n;
    return head;
}

void linklist::display() 
{
    Node* p;
    p = head->next;
    while (p) 
    {
        cout << p->data << ' ';
        p = p->next;
    }
    cout << endl;
}

int main() 
{
    int n;
    cin >> n;
    linklist p;
    Node* head;
    head = p.CreateNode(n);
    p.display();

    int n1, n2;
    cin >> n1 >> n2;
    if (p.swap(n1, n2) == 0) 
        p.display();
    else cout << "error" << endl;
    cin >> n1 >> n2;
    if (p.swap(n1, n2) == 0) 
        p.display();
    else cout << "error" << endl;
}

【id:79】【20分】C. DS单链表--合并 

#include <iostream>
#include <stdlib.h>
using namespace std;

class Node 
{
public:
    int data;
    Node* next;

    Node() 
    {
        next = NULL;
        data = 0;
    }
};

class linklist 
{
public:
    Node* head;
    int length;


    linklist();

    Node* CreateNode(int n);

    int listmerge(Node* La, Node* Lb);

    void display();
};

linklist::linklist() 
{
    head = new Node();
    length = 0;
}

Node* linklist::CreateNode(int n) 
{
    Node* tail = head, * s;
    int i;
    for (i = 0; i < n; i++) 
    {
        s = new Node;
        cin >> s->data;
        tail->next = s;
        tail = s;
    }
    s = NULL;
    delete s;
    length += n;
    return head;
}

int linklist::listmerge(Node* La, Node* Lb) 
{
    Node* pa, * pb, * p;
    pa = new Node;
    pb = new Node;
    p = new Node;
    pa = La->next;
    pb = Lb->next;
    p = head;
    if (!pa || !pb) 
        return 0;
    while (pa && pb) 
    {
        if (pa->data <= pb->data) 
        {
            p->next = pa;
            p = pa;
            pa = pa->next;
        }
        else 
        {
            p->next = pb;
            p = pb;
            pb = pb->next;
        }
    }
    p->next = pa ? pa : pb;
    return 1;
}

void linklist::display() 
{
    Node* p;
    p = head->next;
    while (p) 
    {
        cout << p->data << ' ';
        p = p->next;
    }
    cout << endl;
}


int main() 
{
    int n;
    linklist p, q, r;
    Node* La, * Lb;
    La = new Node;
    Lb = new Node;
    cin >> n;
    La = p.CreateNode(n);
    cin >> n;
    Lb = q.CreateNode(n);
    if (r.listmerge(La, Lb))
        r.display();
}

【id:73】【10分】D. DS循环链表—约瑟夫环(Ver. I - A)

#include<iostream>
#include<stdio.h>
using namespace std;

typedef struct Node
{
	int data;
	struct Node* next;
}Node;

void CreateNode(Node* H, int& n)
{
	H->next = NULL;
	struct Node* p = H, * s;
	int e = 0, i;

	for (i = 0; i < n; i++)
	{
		++e;
		s = new Node; s->next = NULL; s->data = e;
		p->next = s;
		p = s;
	}
	p->next = H->next;
}

void find(Node* Jose, int n, int k, int s)
{
	int i;
	struct Node* p = Jose;
	struct Node* q = NULL;

	while (p->data != s)
		p = p->next;

	while (p->next != p) 
	{
		for (i = 0; i < k - 1; i++)
		{
			q = p;
			p = p->next;
		}
		cout << p->data << " ";

		q->next = p->next;
		p = q->next;
	}
	cout << p->data << " ";
	cout << endl;
}

int main()
{
	int k, n, s, i;

	while (scanf("%d%d%d", &n, &k, &s) != EOF)
	{
		Node* L = new Node;
		CreateNode(L, n);

		find(L, n, k, s);
		delete L;
	}
	return 0;
}

【id:78】【5分】E. DS线性表—多项式相加

#include <iostream>
#include <stdlib.h>
using namespace std;

int poly1(int a) 
{
    if (a < 0) 
    {
        cout << '(' << a << ')';
        return 1;
    } 
    else if (a > 0) 
    {
        cout << a;
        return 1;
    } 
    else 
        return 0;
}

int poly2(int a) 
{
    if (a < 0) 
    {
        cout << "x^(" << a << ')';
        return 1;
    }
    else if (a > 0) 
    {
        cout << "x^" << a;
        return 1;
    } 
    else
        return 0;
}

class Node 
{
public:
    int xishu;
    int zhishu;
    Node *next;

    Node()
    {
        next = NULL;
        xishu = 0;
        zhishu = 0;
    }
};

class linklist 
{
public:
    Node *head;
    int length;

    void *AddPoly(Node *La, Node *Lb);

    linklist();

    Node *CreateNode(int n);

    void display();
};

linklist::linklist() 
{
    head = new Node();
    length = 0;
}

void *linklist::AddPoly(Node *La, Node *Lb)
{
    Node *pa, *pb, *p;
    p = head=La;
    pa = La->next;
    pb = Lb->next;
    while (pa != NULL && pb != NULL)
    {
        if (pa->zhishu < pb->zhishu)
        {
            p->next = pa;
            p = pa;
            pa = pa->next;
        } 
        else if (pa->zhishu > pb->zhishu) 
        {
            p->next = pb;
            p = pb;
            pb = pb->next;
        }
        else 
        {
            int x = pa->xishu + pb->xishu;
            if (x == 0) 
            {
                Node *temp1, *temp2;
                temp1 = pa;
                pa = pa->next;
                free(temp1);
                temp2 = pb;
                pb = pb->next;
                free(temp2);
            } 
            else 
            {
                Node *temp;
                p->next = pa;
                pa->xishu = x;
                p = pa;
                pa = pa->next;
                temp = pb;
                pb = pb->next;
                free(temp);
            }
        }
    }
    if (pa == NULL) 
        p->next = pb;
    else
        p->next = pa;
    return p;
}

void linklist::display() 
{
    Node *p;
    p = head->next;
    int i, count = 0, j;
    while (p) 
    {
        if (p->xishu != 0)
            count++;
        p = p->next;
    }
    p = head->next;
    for (i = 1, j = 1; i <= count; i++,j++) 
    {
        if (poly1(p->xishu)) 
        {
            poly2(p->zhishu);
            if (j != count) 
            {
                cout << " + ";
            }
        }
        p = p->next;
    }
    cout << endl;
}

Node *linklist::CreateNode(int n)
{
    Node *tail = head, *s;
    int i;
    for (i = 0; i < n; i++) 
    {
        s = new Node;
        cin >> s->xishu >> s->zhishu;
        tail->next = s;
        tail = s;
    }
    s = NULL;
    delete s;
    length = length + n;
    return head;
}

int main() 
{
    int t, n;
    cin >> t;
    while (t--) 
    {
        cin >> n;
        int i;
        linklist p, q, r;
        Node *La, *Lb;
        La = p.CreateNode(n);
        p.display();

        cin >> n;
        Lb = q.CreateNode(n);
        q.display();

        r.AddPoly(La, Lb);
        r.display();
    }
}

【id:77】【5分】F. DS链表—学生宿舍管理（双向列表容器List）

#include <iostream>
#include <list>
using namespace std;

struct Room 
{
    string name;
    int stu_num;
};

bool operator< (const Room& r1, const Room& r2) 
{
    if (r1.stu_num < r2.stu_num) 
    {
        return 1;
    }
    return 0;
}

typedef list<Room> listint;

int main() 
{
    listint used_room;
    listint empty_room;
    int t; 
    cin >> t; 
    int room[100], no_room[20] = { 0 };
    for (int i = 0; i < t; ++i) 
    {
        string name;
        int stu_num;
        cin >> name >> stu_num;
        room[i] = stu_num;
        used_room.push_back({ name,stu_num });
    }
    for (int i = 101; i <= 120; ++i) 
    {
        int flag = 0;
        for (int j = 0; j < t; ++j) 
        {
            if (room[j] == i) 
                flag = 1;
        }
        if (flag == 0)
            empty_room.push_back({ "",i });
    }
    int n; 
    cin >> n;
    while (n--) 
    {
        string control; 
        cin >> control;
        if (control == "assign") 
        {
            string name;
            cin >> name;
            int roomnum = empty_room.front().stu_num;
            empty_room.pop_front();
            used_room.push_front({ name,roomnum });
        }
        else if (control == "return") 
        {
            int num; cin >> num;
            for (auto it = used_room.begin(); it != used_room.end(); it++) 
            {
                if (it->stu_num == num) 
                {
                    used_room.erase(it);
                    break;
                }
            }
            empty_room.push_back({ "",num });
        }
        else if (control == "display_used") 
        {
            listint::iterator it;
            used_room.sort();
            for (it = used_room.begin(); it != used_room.end(); it++) 
            {
                if (it != used_room.begin())cout << "-";
                cout << it->name << "(" << it->stu_num << ")";
            }
            cout << endl;
        }
        else if (control == "display_free") 
        {
            listint::iterator it;
            for (it = empty_room.begin(); it != empty_room.end(); it++)
            {
                if (it != empty_room.begin())cout << "-";
                cout << it->stu_num;
            }
            cout << endl;
        }
    }
}

Phoenix0427
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
链表实验报告1
08-03
2. 链表可以用来实现栈、队列和树等数据结构。 3. 链表可以用来解决许多实际问题，例如排序、搜索和合并数据等。 4. 链表可以使用冒泡排序算法和归并排序算法来实现排序和合并。 5. 链表可以用来实现各种数据结构和...
实验三 链表的实现和应用
01-05
“#” 2.“a#” 3.“ab#” 4.“abcd#” 2.编写算法，实现在带有头结点的单链表中按序号查找的函数。 假设单链表中包含6个数据元素，测试数据： 1. 查找第0个. 2. 查找第1个. 3. 查找第2个. 4. 查找第6个. 5. 查找第7...
数据结构实验——实验二链表实验
qq_65814357的博客
06-10 1907
一、 实验任务编写算法实现下列问题的求解。(1)在第i个结点位置插入值为x的结点。实验测试数据基本要求：第一组数据：单链表长度n≥10，x=100, i分别为5,n,n+1,0,1,n+2第二组数据：单链表长度n=0，x=100，i=5(2)删除单链表中第i个元素结点。实验测试数据基本要求：第一组数据：单链表长度n≥10，i分别为5,n,1,n+1,0第二组数据：单链表长度n=0， i=5(3)在一个递增有序的单链表L中插入一个值为x的元素，并保持其递增有序特性。实验测试数据基本要求：单链表元素为 （10
数据结构实验4：链表的基本操作
weixin_58628068的博客
01-10 1210
尾插法是一种在单链表中插入节点的方法，它将新节点插入到链表的尾部。相对于头插法，尾插法需要遍历整个链表找到尾节点，然后在尾节点之后插入新节点。在链表中查找元素的操作通常包括遍历链表，逐一比较节点的值，直到找到匹配的元素或者到达链表的末尾。带头结点的循环双向链表在链表尾部连接到头结点，同时每个节点都有一个指向前一个节点的指针。头插法是一种在单链表中插入节点的方法，它将新节点插入到链表的头部，成为新的头结点。每个节点有两个指针，一个指向前一个节点，另一个指向下一个节点。尾节点的指针指向头节点，形成一个闭环。
数据结构教程实验二链表基本操作的实现
Annzz123的博客
06-16 1634
1.实现单链表各种基本运算在实现单链表各种基本运算的基础上，设计主程序，完成如下功能：（1）初始化单链表h。（2）依次采用尾插法插入12，25，7，9，10共5个元素。（3）输出单链表h。 4）输出单链表h的长度5）判断单链表h是否为空。（6）输出单链表h第4个元素。（7）输出元素5的位置。（8）在第4个元素的位置上插入元素100。（9）输出单链表h。（10）删除单链表h的第3个元素。（11）输出单链表h。（12）释放单链表h。
链表的操作实验
夏日漱石的博客
05-12 1442
单链表
数据结构实验一(2) 链表的基本操作
流苏的博客
05-21 2234
数据结构实验一(2) 链表的基本操作
Python数据结构实验 链表的实现
Jiangxia13的博客
03-21 2170
基础实验题 设计整数单链表的基本运算程序，并用相关数据进行测试。 应用实验题 由1~ n（例如n=10 000 000）的n个整数建立顺序表a（采用列表表示）和带头结点的单链表h，编写一个实验程序输出分别将所有元素逆置的时间。
【数据结构实验】链表
PWrose的博客
10-28 1122
3.（附加题）对任务1或者2中创建的某一个单链表{A1,B1,A2,B2,…,An,Bn}，编写一个算法将它拆分为两个单链表，分别为：{A1,A2,…,An}和{Bn,…2.在main()函数中，调用头插法（CreateListF()函数）和尾插法（CreateListR()函数），创建新链表，并输出结果进行比较；1.实现单链表各种基本运算的算法；
数据结构实验之链表一：顺序建立链表
dwjg123的博客
03-13 1109
7-1 数据结构实验之链表一：顺序建立链表单位 山东理工大学输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。
Vj实验四链表描述线性表一
weixin_53437436的博客
10-27 676
A 要求： 封装链表类，链表迭代器类 链表类需提供操作：在指定位置插入元素，删除指定元素，搜索链表中是否有指定元素，原地逆置链表，输出链表 不得使用与链表实现相关的STL 描述： 第一行两个整数 N 和 Q。 第二行 N 个整数，作为节点的元素值，创建链表。 接下来 Q 行，执行各个操作，具体格式如下： 插入操作:1 idx val，在链表的idx位置插入元素val; 删除操作:2 val，删除链表中的val元素。若链表中存在多个该元素，仅删除第一个。若该元素不存在，输出-...
c语言链表实验作业,C语言链表实验报告.doc
weixin_39827775的博客
05-16 542
C语言链表实验报告链表实验报告实验名称链表操作的实现--学生信息库的构建(1)理解单链表的存储结构及基本操作的定义(2)掌握单链表存储基本操作(3)学会设计实验数据验证程序【实验仪器及环境】计算机 Window XP操作系统三、实验内容1、建立一个学生成绩信息(学号，姓名，成绩)的单链表，按学号排序2、对链表进行插入、删除、遍历、修改操作。3、对链表进行读取(读文件)、存储(写文件)?四、实验要求...
链表排序北邮数据结构实验
11-13
链表排序北邮数据结构实验报告 链表排序是数据结构中的一种基本操作，旨在对链表中的元素进行排序。该实验报告旨在使用链表实现各种排序算法，并进行比较。 一、实验要求 实验要求使用链表实现以下五种排序...
实验2链表验证实验.doc
10-01
实验2链表验证实验.doc
实验2-链表20240409.zip
04-10
在这个实验"实验2-链表20240409"中，我们很显然会深入探讨链表的相关概念、操作以及实现。虽然没有具体的标签，但我们可以假设这个实验涵盖了链表的基本操作，如创建、插入、删除、遍历等。 链表不同于数组，它的...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1131
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++二叉搜索树
Jk_Mr的博客
07-20 1129
树结构是一种重要的数据结构。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
C++笔试强训7
m0_74189279的博客
07-21 972
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
商品信息管理系统(C语言)
最新发布
zeyeqianli的博客
07-22 325
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
数据结构实验 城市链表
05-04
City *paris = create_city("Paris", 2141000, 48.8566, 2.3522); City *new_york = create_city("New York", 8623000, 40.7128, -74.0060); // Add cities to the list City *head = NULL; head = add_city...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值