数据结构——单链表

已于 2022-04-02 17:13:43 修改
阅读量1.5k 收藏 4
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 链表
于 2022-04-02 17:12:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HcViking/article/details/123922032
版权

单链表就是线性表的链式存储结构一般使用的是带头节点的链表，如图所示就是带头结点的单链表（我是用的语法是C++的）

带头结点的好处

  1. 有了头节点以后，链表中的首结点的插入和删除操作与其他结点一致。
  2. 无论单链表是否为空都一个头结点，也由此统一了空表和非空表的处理过程。

单链表基本操作

void InitList(LinkNode* &L)//初始化一个链表
void CreateList_Head(LinkList*& L, Elemtype a[], int n)//头插法创建链表
void CreateList_Tail(LinkList*& L, Elemtype a[], int n)//尾插法创建链表
void DestoryList(LinkNode* &L)//销毁一个链表
bool ListEmpty(LinkList* &L)//判断链表是否为空
int ListLength(LinkList* &L)//求出链表的长度
void DispList(LinkList* &L)//输出链表中的所有元素
bool Get_Elem_List(LinkList *&L,int i,Elemtype &e)//求链表中第i个位置的元素
int LocateList(LinkList *&L ,Elemtype e)//找到链表中第一个值为e的元素的位置
bool InsertList(LinkList *&L,int i,Elemtype e)//在第i个位置插入元素e
bool DeleteList(LinkList *& L ,int i)//删除第i个位置的元素

第一步是重中之重——创建单链表类型

typedef int Elemtype;
typedef struct List {
    Elemtype data;    //存放元素
    List* next;       //指向后继结点
}LinkList;            //单链表结点类型

其次就是初始化链表

创立一个头结点

void InitList(LinkList*& L)
{
    L = new LinkList;//创建头结点
    L->next = NULL;
}

建立单链表的秘籍1——头插法

注：头插法建立的单链表与实际输入的数据的次序是相反的

void CreateList_Head(LinkList*& L, Elemtype a[], int n)
{
    LinkList* p;
    L = new LinkList;//就是 L = (LinkList *)malloc(sizeof (LinkList));
    L->next = NULL;
    for (int i = 0; i < n; i++)
    {
        p = new LinkList;//与malloc作用一致
        p->data = a[i];
        p->next = L->next;
        L->next = p;
    }
}

秘籍2——尾插法

注：尾插法建立的链表与实际输入的数据的次序是一致的

void CreateList_Tail(LinkList*& L, Elemtype a[], int n)
{
    LinkList* p, * s;
    L = new LinkList;//malloc
    L->next = NULL;
    s = L;
    for (int i = 0; i < n; i++)
    {
        p = new LinkList;//malloc
        p->data = a[i];
        s->next = p;
        s = p;
    }
    s->next = NULL;
}

下面就是线性表的基本运算在单链表中的实现

~初始化在上文已经提及就不再赘述了

·销毁线性表

释放单链表L占用的内存空间——逐一释放全部结点的空间。

void DestoryList(LinkList*& L)
{
    LinkList* pre = L, * p = pre->next;    // pre 指向 p 的前驱节点
    while (p != NULL)                      //扫描单链表 L
    {
        delete pre;                        //释放 pre 结点 
        pre = p;                           //pre、p 同步后移一个结点
        p = pre->next;
    }
    delete pre;                            //循环结束时 p 为 NULL ，pre指向尾结点，释放它
}
//也可以用 free(); 来释放结点的内存

·判断链表是否为空

如果链表为空 返回 true 否则返回 false

bool ListEmpty(LinkList*& L)
{
    return (L->next == NULL);//头结点指向NULL说明没有元素存在于链表中
}

·求链表的长度

就是遍历一次链表返回链表的数据结点个数即他的长度

int ListLength(LinkList*& L)
{
    int len = 0;
    LinkList* p = L->next;
    while (p != NULL)            //遍历链表
    {
        len++;
        p = p->next;
    }
    return len;
}

·输出链表

逐一扫描单链表L的每个数据结点，并显示各个结点data域值

void DispList(LinkList*& L)
{
    LinkList* p = L->next;
    while (p != NULL)
    {
        cout << p -> data;
        p = p->next;
    }
    puts("");
}

·求出链表中的某个数据元素值

在链表上找到第i个节点，若存在第i个数据节点，则将其data域值返回

bool Get_Elem_List(LinkList*& L, int i, Elemtype& e)
{
    int cnt = 0;
    LinkList* p = L;
    if (i < 0) return false;
    while (cnt < i && p != NULL)
    {
        cnt++;
        p = p->next;
    }
    if (p == NULL) return false;
    else
    {
        e = p->data;
        return true;
    }
}

·按元素值查找

在单链表L中从头开始找第一个值域和e相等的结点，若这个结点存在，就返回其逻辑序号，否则返回-1.

int LocateList(LinkList*& L, Elemtype e)
{
    int pos = 1;              //p指向首结点，pos设置为1
    LinkList* p = L -> next;
    while (p != NULL && p->data != e )
    {
        pos++;
        p = p->next;
    }
    if (p == NULL)
        return 0;
    else
        return pos;
}

·插入数据元素

在单链表L中找到第 i - 1个结点，由p指向它。若存在这样的结点，将值为e的结点(s指向它)插入到p所指向的结点的后面

就是如图的操作 为了防止p的下一个结点的丢失，所以要按如上顺序进行操作

bool InsertList(LinkList*& L, int i, Elemtype e)
{
    int cnt = 0;
    LinkList* p = L, * s;
    if (i <= 0) return false;
    while (cnt < i - 1 && p != NULL)
    {
        cnt++;
        p = p->next;
    }
    if (p == NULL)
        return false;
    else
    {
        s = new LinkList;    //生成新的结点进行插入操作
        s->data = e;         //给新结点s赋值
        s->next = p->next;
        p->next = s;
        return true;
    }
}

 ·最后一个操作——删除数据元素

在链表中找到第i-1个结点，由p指向它。若存在就返回其域值并删除结点后返回true，否则返回false

 第二种方法是当你不需要知道删除的元素是什么的时候使用

bool DeleteList(LinkList*& L, int i)
{
    int j = 0;
    Elemtype e;
    LinkList* p = L, * q;
    if (i <= 0) return false;
    while (j < i - 1 && p != NULL)
    {
        j++;
        p = p->next;
    }
    if (p == NULL) return false;
    else
    {
        q = p->next;
        if (q == NULL)
            return false;
        e = q->data;
        p->next = q->next;
        delete q;
        return true;
    }
}

那么所有的操作到此就结束了//因为是C语言上的数据结构所以没有写C++的链表实现方式。

下面是一个 对学生数据类型的单链表实例

Code

#include <iostream>
#include <algorithm>
#include <string>
#define la_ji_lian_biao ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);
using namespace std;
//typedef int Elemtype;
struct Stu {
    int id;
    string name;
    int score;
};
typedef Stu Elemtype;
typedef struct List {
    Elemtype data;
    List* next;
}LinkList;
//头插法创建链表
void CreateList_Head(LinkList*& L, Elemtype a[], int n)
{
    LinkList* p;
    L = new LinkList;
    L->next = NULL;
    for (int i = 0; i < n; i++)
    {
        p = new LinkList;
        p->data = a[i];
        p->next = L->next;
        L->next = p;
    }
}
//尾插法创建链表
void CreateList_Tail(LinkList*& L, Elemtype a[], int n)
{
    LinkList* p, * s;
    L = new LinkList;
    L->next = NULL;
    s = L;
    for (int i = 0; i < n; i++)
    {
        p = new LinkList;
        p->data = a[i];
        s->next = p;
        s = p;
    }
    s->next = NULL;
}
//初始化
void InitList(LinkList*& L)
{
    L = new LinkList;
    L->next = NULL;
}
//销毁链表
void DestoryList(LinkList*& L)
{
    LinkList* pre = L, * p = pre->next;
    while (p != NULL)
    {
        delete pre;
        pre = p;
        p = pre->next;
    }
    delete pre;
}
//判断链表是否为空
bool ListEmpty(LinkList*& L)
{
    return (L->next == NULL);
}
//求链表的长度
int ListLength(LinkList*& L)
{
    int len = 0;
    LinkList* p = L->next;
    while (p != NULL)
    {
        len++;
        p = p->next;
    }
    return len;
}
//输出线性表
void DispList(LinkList*& L)
{
    LinkList* p = L->next;
    cout << '\t' << '\t' << "学号" << '\t' << '\t' << "姓名" << '\t' << '\t' << "分数" << endl;
    while (p != NULL)
    {
        cout << '\t' << '\t' << p->data.id << '\t' << '\t' << p->data.name << '\t' << '\t' << p->data.score << endl;
        p = p->next;
    }
    puts("");
}
//求链表中第i个元素的值
bool Get_Elem_List(LinkList*& L, int i, Elemtype& e)
{
    int cnt = 0;
    LinkList* p = L;
    if (i < 0) return false;
    while (cnt < i && p != NULL)
    {
        cnt++;
        p = p->next;
    }
    if (p == NULL) return false;
    else
    {
        e = p->data;
        return true;
    }
}
//查找第一个学号为e的元素序号（位置）
int LocateList(LinkList*& L, Elemtype e)
{
    int pos = 0;
    LinkList* p = L;
    while (p != NULL && p->data.id != e.id )
    {
        pos++;
        p = p->next;
    }
    if (p == NULL)
        return 0;
    else
        return pos + 1;
}
//插入第i个元素
bool InsertList(LinkList*& L, int i, Elemtype e)
{
    int cnt = 0;
    LinkList* p = L, * s;
    if (i <= 0) return false;
    while (cnt < i - 1 && p != NULL)
    {
        cnt++;
        p = p->next;
    }
    if (p == NULL)
        return false;
    else
    {
        s = new LinkList;
        s->data = e;
        s->next = p->next;
        p->next = s;
        return true;
    }
}
//删除第i个元素
bool DeleteList(LinkList*& L, int i)
{
    int j = 0;
    Elemtype e;
    LinkList* p = L, * q;
    if (i <= 0) return false;
    while (j < i - 1 && p != NULL)
    {
        j++;
        p = p->next;
    }
    if (p == NULL) return false;
    else
    {
        q = p->next;
        if (q == NULL)
            return false;
        e = q->data;
        p->next = q->next;
        delete q;
        return true;
    }
}

int main()
{
    la_ji_lian_biao;
    LinkList* list;
    //初始化链表
    InitList(list);
    //判断是否为空
    if (ListEmpty(list)) puts("YES,list is empty!");
    else puts("NO,List is not empty!");
    puts("显示YES , 初始化成功 ，若输出NO，请重新运行程序");
    int n;
    Elemtype a[55];
    puts("请输入学生的数量 以及每个同学的学号、姓名、成绩");

    cin >> n;
    for (int i = 0; i < n; i++)    cin >> a[i].id >> a[i].name >> a[i].score;
    CreateList_Tail(list, a, n);

    cout << "链表list的长度为： " << ListLength(list) << endl;

    cout << "输出链表" << endl;
    DispList(list);

    cout << "请输入你要插入的同学的序号、学号、姓名、分数" << endl;
    int pos; Elemtype s;
    cin >> pos >> s.id >> s.name >> s.score;
    InsertList(list, pos, s);

    cout << "输出链表" << endl;
    DispList(list);

    cout << "请输入你要删除的同学的序号： "; int num; cin >> num;
    DeleteList(list, num);

    cout << "输出链表" << endl;
    DispList(list);
    
    cout << "查找第 x 个同学 并输出该同学的信息 " << endl;
    int x; Elemtype e;
    cin >> x;
    Get_Elem_List(list, x, e);
    cout << endl;
    cout << "该同学的学号为： " << e.id << endl << "该同学的姓名为： " << e.name << endl << "该同学的成绩为： " << e.score << endl;
   
    cout << "输出链表" << endl;
    DispList(list);

    cout << "删除链表";
    DestoryList(list);
    //if (ListEmpty(list)) cout << "删除成功" << endl;
    /*cout << "输出链表" << endl;
    DispList(list);*/
    return 0;
}

He_xj
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构——单链表实验
06-15
熟悉单链表的定义，单链表的建立方法及相关基本操作，理解单链表的基本思想，能够根据实际情况选择合适的存储结构。 2.实验内容 1、利用头插法或尾插法建立单链表 2、对已建立的单链表实现插入、删除等基本操作； 3...
线性表基本运算在单链表中的实现
weixin_45959708的博客
08-18 815
#include <stdio.h> #include <malloc.h> #define Maxsize 50; typedef int ElemType; //假设ElemType为int类型，使用以下自定义类型语句： typedef struct LNode { ElemType data; //存放元素值 struct LNode *next;//指向后继节点 }LinkNode; //单链表结点类型 //1.初始化线性表L
数据结构3_线性表 _单链表的基本操作及实现
毛钱儿的博客
04-09 1632
数据结构3_线性表_2 总览： 线性表： 线性表是具有相同数据类型的n(n>=0)个数据元素的有序序列，其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，其一般表示为： L=(a1,a2,a3,a4,∗∗∗,an) L = (a1,a2,a3,a4,***,an) L=(a1,a2,a3,a4,∗∗∗,an) a1为表头元素，an为表尾元素，除了an其他元素都有唯一的直接后继，除...
数据结构线性表实现单链表各种基本运算
weixin_57011178的博客
10-04 2044
单链表的各种基本运算 文章目录 前言 一，头插法，与尾插法 二，各种基本运算 三，代码展示 ​​​​​​​总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库..
代码实现头插法建立一个带头结点的单链表，输入-1表示结束
m0_58323186的博客
11-09 1180
数据结构代码题
带头节点的单链表的基本创建与操作函数
weixin_55626610的博客
11-04 790
我们在链表的头部加入一个“头结点”，如果没有头结点，第一个结点的插入和删除操作跟其他结点不同，需要单独分析，为了省去这个麻烦，因此我们定义了一个头结点，头结点的类型与数据结点一致，标识链表的头指针变量L中存放该结点的地址，这样即使是空表，头指针变量L也不为空了。
JAVA数据结构——单链表的操作.docx
07-11
JAVA数据结构——单链表的操作 单链表的操作 方法一： package ch02; (1)建立结点类Node.java public class Node { public Object data;//存放结点数据值 public Node next;//存放后继结点 //无参构造函数 public ...
数据结构——单链表.zip
09-16
完全实现严蔚敏数据结构教材中的单链表，可测试。包含初始化，插入，删除，连接等操作
数据结构——单链表（C语言版）.zip
11-02
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储...
数据结构学习笔记——单链表
12-21
链表（linked list）是一种在物理上非连续，非顺序的数据结构，由若干节点（node）组成 单链表每一个节点又包含两部分，1是存放数据的变量data，2是存放指向下一个结点的指针next 双向链表每一个节点包含三部分，在...
数据结构（线性表的基本运算在单链表上的实现）
m0_52180541的博客
10-17 278
.cpp #include"SLinkNode.h" #include<Stdio.h> void main() { // LinkList L; int i;ElemType e; LNode *L; InitList(L); //初始化 InsElem(L,2,1);InsElem(L,1,2); //插入 InsElem(L,4,3);InsElem(L,6,4); InsElem(L,3,5);InsElem(L,5,6); InsE
单链表的创建及相关操作——入门级
qq_21493707的博客
03-14 1343
本文我们将学习单链表的创建以及相关操作。使用c语言实现，结尾有全部代码。 （仅供正在学习的朋友参考，如有错误的地方，欢迎评论指出。）
【数据结构】——单链表的基本操作（带头结点）
最新发布
weixin_51398574的博客
07-01 3770
1.在单链表的定义中不能省略结构体名称LNode（第2行中）。原因：在该结构体内部使用到了该结构体类型去定义next指针域。2.第5行中的重命名LNode和*LinkList的意义：//将结构体重命名为LNode//将结构体的指针重命名为LinkList。
线性表——单链表的C语言实现
qq_41536160的博客
12-17 1133
单链表——线性表链式存储结构的特点是：用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。为了表示每个数据元素aia_iai​与其直接后继数据元素 之间的逻辑关系，对数据元素aia_iai​来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置）。 这两部分信息组成数据元素aia_iai​的存储映像，称为结点。 单链表的C语言实现 状态码 #include<stdio.h> #include<stdlib.h> /
单链表的创建及操作
北极星的博客
03-15 1719
1、创建一个带头结点的单链表（头指针为head），且遍历此链表（输出链表中各结点的值）； 2、查找单链表中的第i个结点，并输出结点元素的值； 3、在单链表中的第i个结点前插入一个结点值为e的正整数(从外部输入); 4、删除单链表中的第j个结点； 5、将单链表中的各结点就地逆序（不允许另建一个链表）； #include #include #include using namespace std; t...
java带头结点的单链表_Java实现带头结点的单链表
weixin_42629815的博客
02-13 256
链表的特点1，以节点方式存储，是链式结构。2，每个节点包含data域，next域：指向下一个节点。3，链表的各个节点不一定是连续存储。4，链表分为带头节点和不带头节点两种类型的链表。实现原理添加节点：如下图所示，首先遍历原有链表，找到最后一个节点，将要增加的节点添加到该节点的后面。下面介绍如何找到最后一个节点。思路是这样的，先遍历整个链表，定义一个辅助变量temp，用于暂时存储遍历出来的各个节点。...
数据结构——线性表（二）：单链表的实现
baidu_41892919的博客
05-05 276
单链表介绍及实现单链表的基本概念单链表的示意图单链表的基本运算及实现创建一个空表插入一个元素寻找一个元素删除一个元素判断是否为空表清空表删除表排序说明 单链表的基本概念 线性表的链式存储结构就是链表。 将线性表L=（a0，a1……,an-1）中各元素分布在不同的存储块称为节点。 单链表的每个节点中除数据域以外还有一个指针域，用来指向其后续节点，其最后一个节点的指针域为空（NULL）。 节点结构 ...
Java实现单链表（步骤详解+源码）
GSCY
10-14 6411
Java实现单链表（步骤详解+源码） 欢迎大家提出问题，一起学习！
带头单链表Java实现
weixin_62756510的博客
04-27 867
目录带头单链表一、概念二、要点总结三、代码实现1. 类结构2. 带头单链表的遍历3. 插入结点3. 1. 头插法3.2. 指定索引处插入结点3.3 尾插法4. 删除结点4.1. 删除指定索引处的结点4.2 删除所有值为val的结点 带头单链表 一、概念 带头单链表中默认带有一个虚拟头结点dummyHead，不存储有效元素。 二、要点总结 链表中仅创建了虚拟头结点的Node对象 private Node dummyHead = new Node(); 虚拟头结点的属性值val默认为0（不存储有效元素），
C++数据结构——中序遍历二叉树
05-23
中序遍历是二叉树遍历的一种，遍历顺序为左子树、根节点、右子树。以下是C++代码实现： ```c++ #include <iostream> using namespace std; struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; void inorderTraversal(TreeNode* root) { if(root == NULL) return; inorderTraversal(root->left); cout << root->val << " "; inorderTraversal(root->right); } int main() { TreeNode* root = new TreeNode(1); root->right = new TreeNode(2); root->right->left = new TreeNode(3); inorderTraversal(root); return 0; } ``` 输出结果为：1 3 2 这里我们只是简单地输出了遍历的结果，实际应用中可以对遍历到的节点进行其他操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

He_xj

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值