单链表——单链表的定义及基本操作（初始化、头插法尾插法建表、查找、插入、删除、判空等）

已于 2022-03-28 20:04:14 修改
阅读量9.6w 收藏 2.1k
点赞数 396
分类专栏： 经典编程题——线性表 文章标签： 指针 算法 链表
于 2021-04-17 23:47:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44162361/article/details/115795646
版权

文章目录

单链表的定义

  由于顺序表的插入删除操作需要移动大量的元素，影响了运行效率，因此引入了线性表的链式存储——单链表。单链表通过一组任意的存储单元来存储线性表中的数据元素，不需要使用地址连续的存储单元，因此它不要求在逻辑上相邻的两个元素在物理位置上也相邻。

  单链表的特点：

  1. 单链表不要求逻辑上相邻的两个元素在物理位置上也相邻，因此不需要连续的存储空间。
  2. 单链表是非随机的存储结构，即不能直接找到表中某个特定的结点。查找某个特定的结点时，需要从表头开始遍历，依次查找。

 对于每个链表结点，除了存放元素自身的信息外，还需要存放一个指向其后继的指针。
 单链表中结点类型的描述：

typedef struct LNode{ //定义单链表结点类型
	int data; //数据域，可以是别的各种数据类型，本文统一用int类型
	struct LNode *next; //指针域
}LNode, *LinkList;

单链表上的操作

初始化

 通常会用头指针来标识一个单链表，头指针为NULL时表示一个空表。但是，为了操作方便，会在单链表的第一个结点之前附加一个结点，称为头结点。头结点的数据域可以不设任何信息，也可以记录表长等信息。头结点的指针域指向线性表的第一个元素结点。如下图所示：
在这里插入图片描述
 头结点和头指针的区分：不管带不带头结点，头指针始终指向单链表的第一个结点，而头结点是带头结点的单链表中的第一个结点，结点内通常不存储信息。
 那么单链表的初始化操作就是申请一个头结点，将指针域置空。

void InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LinkList));
    L->next = NULL;
}

建立单链表

头插法建立单链表

 所谓头插法建立单链表是说将新结点插入到当前链表的表头，即头结点之后。如图所示：

在这里插入图片描述
 算法思想：首先初始化一个单链表，其头结点为空，然后循环插入新结点*s：将s的next指向头结点的下一个结点，然后将头结点的next指向s。

 实现代码：

//头插法建立单链表
LinkList HeadInsert(LinkList &L){
    InitList(L); //初始化
    int x;
    cin>>x;
    while(x!=9999){ //输入9999表示结束
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;
        cin>>x;
    }
    return L;
}

 需要指出的是，头插法建立的单链表中结点的次序和输入数据的顺序不一致，是相反的。若希望两者的顺序是一致的，则可采用尾插法建立单链表。

尾插法建立单链表

 所谓尾插法建立单链表，就是将新结点插入到当前链表的表尾。如下图所示：
在这里插入图片描述
  算法思想：首先初始化一个单链表，然后声明一个尾指针r，让r始终指向当前链表的尾结点，循环向单链表的尾部插入新的结点*s，将尾指针r的next域指向新结点，再修改尾指针r指向新结点，也就是当前链表的尾结点。最后别忘记将尾结点的指针域置空。

 实现代码：

//尾插法建立单链表
LinkList TailInsert(LinkList &L){
    InitList(L);
    LNode *s,*r=L;
    int x;
    cin>>x;
    while(x!=9999){
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;
        cin>>x;
    }
    r->next = NULL;
    return L;
}

遍历单链表

 算法思想：声明一个指针p，从头结点指向的第一个结点开始，如果p不为空，那么就输出当前结点的值，并将p指向下一个结点，直到遍历到最后一个结点为止。

 实现代码：

//遍历操作
void PrintList(LinkList L){
    LNode *p = L->next;
    while(p){
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}

求单链表的长度

 算法思想：声明一个指针p，p指向头结点指向的第一个结点，如果p指向的结点不为空，那么长度加一，将p指向下一个结点，直到遍历到最后一个结点为止。

 实现代码：

//求单链表的长度
int Length(LinkList L){
    LNode *p = L->next;
    int len = 0;
    while(p){
        len++;
        p = p->next;
    }
    return len;
}

查找操作

按值查找

 查找值x在单链表L中的结点指针。

 算法思想：从单链表的第一个结点开始，依次比较表中各个结点的数据域的值，若某结点数据域的值等于x，则返回该结点的指针；若整个单链表中没有这样的结点，则返回空。

 实现代码：

//按值查找：查找x在L中的位置
LNode *LocateElem(LinkList L, int x){
    LNode *p = L->next;
    while(p && p->data != x){
        p = p->next;
    }
    return p;
}

按位查找

 查找单链表L中第 i 个位置的结点指针。

 算法思想：从单链表的第一个结点开始，顺着指针域逐个往下搜索，直到找到第 i 个结点为止，否则返回最后一个结点的指针域NULL。

 实现代码：

//按位查找：查找在单链表L中第i个位置的结点
LNode *GetElem(LinkList L, int i){
    int j=1;
    LNode *p = L->next;
    if(i==0)return L;
    if(i<1)return NULL;
    while(p && j<i){
        p = p->next;
        j++;
    }
    return p; //如果i大于表长，p=NULL,直接返回p即可
}

插入操作

 这里所说的插入是将值为x的新结点插入到单链表L的第i个位置上。（不包括头结点）

 算法思想：从表头开始遍历，查找第 i-1个结点，即插入位置的前驱结点为p，然后令新结点s的指针域指向p的后继结点，再令结点p的指针域指向新结点*s。

 实现代码：

//将x插入到单链表L的第i个位置上
void Insert(LinkList &L, int i, int x){
    LNode *p = GetElem(L,i-1);
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = x;
    s->next = p->next;
    p->next = s;
}

删除操作

 将单链表的第 i 个结点删除。

 算法思想：先检查删除位置的合法性，然后从头开始遍历，找到表中的第 i-1 个结点，即被删除结点的前驱结点*p，被删除结点为*q，修改*p的指针域，将其指向*q的下一个结点，最后再释放结点*q的存储空间。

 实现代码：

//删除操作:将单链表中的第i个结点删除
void Delete(LinkList &L, int i){
    if(i<1 || i>Length(L))
        cout<<"delete failed: index is wrong."<<endl;
        return;
    LNode *p = GetElem(L,i-1);
    LNode *q = p->next;
    p->next = q->next;
    free(q);
}

判空操作

 算法思想：要判断带头结点的单链表是否为空，只需要看头结点的指针域即可，如果头结点的指针域为空，即单链表中只有一个头结点，那么该单链表为空表。

 实现代码：

//判空操作
bool Empty(LinkList L){
    if(L->next == NULL){
        cout<<"L is null"<<endl;
        return true;
    }else{
        cout<<"L is not null"<<endl;
        return false;
    }
}

完整代码及实例

 完整代码：

#include<bits/stdc++.h>
using namespace std;

typedef struct LNode{
    int data;
    struct LNode *next;
}LNode, *LinkList;

//初始化
void InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LinkList));
    L->next = NULL;
}

//遍历操作
void PrintList(LinkList L){
    LNode *p = L->next;
    while(p){
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}

//求单链表的长度
int Length(LinkList L){
    LNode *p = L->next;
    int len = 0;
    while(p){
        len++;
        p = p->next;
    }
    return len;
}

//头插法建立单链表
LinkList HeadInsert(LinkList &L){
    InitList(L); //初始化
    int x;
    cin>>x;
    while(x!=9999){
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;
        cin>>x;
    }
    return L;
}

//尾插法建立单链表
LinkList TailInsert(LinkList &L){
    InitList(L);
    LNode *s,*r=L;
    int x;
    cin>>x;
    while(x!=9999){
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;
        cin>>x;
    }
    r->next = NULL;
    return L;
}

//按值查找：查找x在L中的位置
LNode *LocateElem(LinkList L, int x){
    LNode *p = L->next;
    while(p && p->data != x){
        p = p->next;
    }
    return p;
}

//按位查找：查找在单链表L中第i个位置的结点
LNode *GetElem(LinkList L, int i){
    int j=1;
    LNode *p = L->next;
    if(i==0)return L;
    if(i<1)return NULL;
    while(p && j<i){
        p = p->next;
        j++;
    }
    return p; //如果i大于表长，p=NULL,直接返回p即可
}

//将x插入到单链表L的第i个位置上
void Insert(LinkList &L, int i, int x){
    LNode *p = GetElem(L,i-1);
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = x;
    s->next = p->next;
    p->next = s;
}

//删除操作:将单链表中的第i个结点删除
void Delete(LinkList &L, int i){
    if(i<1 || i>Length(L)){
        cout<<"delete failed: index is wrong."<<endl;
        return;
    }
    LNode *p = GetElem(L,i-1);
    LNode *q = p->next;
    p->next = q->next;
    free(q);
}


int main(){
    //初始化，尾插法建立单链表
    LinkList L = TailInsert(L);
    //插入：在第二个位置插入结点，数据域为888，并遍历单链表
    Insert(L,2,888);
    cout<<"在第二个位置插入888： ";
    PrintList(L);
    //删除：删除第四个结点
    Delete(L,4);
    cout<<"删除第四个结点后：";
    PrintList(L);
    //按位查找：查找第三个结点，并输出其数据域的值
    LNode *p = GetElem(L,3);
    cout<<"第三个结点的值为："<<p->data<<endl;
    //按值查找：查找数据域为2的结点的指针
    LNode *q = LocateElem(L,2);
    cout<<"数据为2的结点的下一个结点的值为："<<q->next->data<<endl;
    //输出单链表的长度
    cout<<"单链表的长度："<<Length(L)<<endl;
    return 0;
}

 执行结果：
在这里插入图片描述

薛定谔的猫ovo
关注
专栏目录
数据结构----单链表的创建及相关操作
2201_75619538的博客
07-01 1048
链表的介绍，创建，遍历，查找，插入和删除详细操作和具体代码实现
单链表的基础操作（头插法、尾插法、插入和删除）
weixin_43260290的博客
09-25 4万+
一、链表的建立（头插法和尾插法） 1、头插法：把后建立的结点插在头部。用这种方法建立起来的链表的实际顺序与输入顺序刚好向反，输出时为倒序！ 下面附上代码： struct node *headcreat() { struct node *p,*q,*head; head = (struct node*)malloc(sizeof(struct node)); p = (struct nod...
数据结构——单链表
最新发布
2301_80401288的博客
08-18 1287
数据结构——单链表 感谢各位的支持！！！
【数据结构】手把手教你单链表（c语言）（附源码）
2301_80955819的博客
07-26 1355
单链表的概念、单链表的结构定义、增删查改等功能实现
C语言单链表实现初始化、创建、增、删、查等基本操作（详细）
莫浅子的博客
08-31 2万+
一、单链表的定义及初始化 1、定义 2、初始化 1)不带头结点的单链表 2)带头节的单链表 二、单链表插入和删除 1)插入 1、按位序插入（带头结点） 2、按位插入（不带头结点） 3、指定结点的后插操作 4、指定结点的前插操作 2）删除 1、按位序删除（带头结点） 2、指定结点删除 3、指定最后结点的删除 三、查找 1）按位查找 2）按值查找 四、建立 1）头插法 2）尾插法 六、补充求单链表长度 ...
单链表——单链表的定义及基本操作（头插法尾插法建表、查找、插入、删除等）
Wanghh520max的博客
03-30 3258
快速掌握单链表的基本操作
单链表
weixin_34122810的博客
12-07 126
1、链接存储方法     　链接方式存储的线性表简称为链表（Linked List）。     　链表的具体存储表示为： 　　① 用一组任意的存储单元来存放线性表的结点（这组存储单元既可以是连续的，也可以是不连续的） 　　② 链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址（或位置）信息（称为指针（pointer）...
链表学习笔记（kk-zkx）
weixin_42585296的博客
09-29 430
链表学习单链表（链式存储结构）链表节点头节点，头指针和首元节点 单链表（链式存储结构） 链表，别名链式存储结构或单链表，用于存储逻辑关系为 “一对一” 的数据。与顺序表不同，链表不限制数据的物理存储状态，换句话说，使用链表存储的数据元素，其物理存储位置是随机的。 栗子，使用链表存储 {1,2,3}，数据的物理存储状态如图 所示： 数据元素随机存储，并通过指针表示数据之间逻辑关系的存储结构就是链式存储结构。 链表节点 链表中每个数据的存储都由以下两部分组成： 数据元素本身，其所在的区域称为数据域； 指向
数据结构（9）单链表基本操作（头插法建立单链表、尾插法建立单链表、查找结点值（按序号和值）、插入、删除、求表长）
李白
05-23 5407
目录 1、采用头插法建立单链表 2、尾插法建立单链表 3、按序号查找结点值 4、按值查找表结点 5、插入结点操作 6、删除操作 7、求表长 本篇博客的结点数据结构如下： typedef struct LNode { ElemType data; struct LNode *next; }LNode,*LinkList; 1、采用头插法建立单链表 该方法从一个空表开始，生成新结点，并将读取到的数据存放到新结点的数据域中，然后将新结点插入到当前链表的表头，
数据结构 链表【单向链表的初始化，头插法建立，尾插法建立，插入，删除】
Kukeoo的博客
02-19 2188
前言 本篇讨论的均为带头结点的单链表。 一、单链表的初始化 先上结构体： typedef struct Node { int data; Node* next; }Node,*LinkedList; Node为struct Node的别名， LinkedList为struct Node*，也就是链表指针的别名。 代码： LinkedList LinkedListInit() { Node* L; L = (Node*)malloc(sizeof(Node)); if (L ==
数据结构——单链表的初始化、建立、插入、删除
TSY_1222的博客
09-25 1万+
目录 1、单链表初始化 2、建立单链表 3、单链表的插入运算 4、单链表的删除运算 线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素（这组存储单元可连续、也可不连续）。 链表优点 链表缺点 1、不要求占用连续的存储空间，可动态进行分配。 2、插入和删除操作效率高，不需要移动元素。 1、不能随意访问任一元素。...
数据结构实战——线性表（顺序表、链表——单链表、双链表、循环链表、静态链表）
wypds的博客
04-09 1026
数据结构线性表实战 顺序表、单链表（头插法、尾插法、双链表、循环链表、静态链表） 一、什么是线性表 二、顺序表 三、链表 一、单链表 1、头插法 2、尾插法 二、双链表 三、循环链表 四、静态链表 前言 提示：这里可以添加本文要记录的大概内容： 数据结构——线性表 提示：以下是本篇文章正文内容，下面案例可供参考 一、什么是线性表 线性表是具有相同数据类型的n(>=0)个数据元素的有限序列，n为表长，n=0时线性表是一个空表。若用L命名线性表，一般表示为：L=(a[1]，a[2]，a[3]，.
数据结构第四篇——（一般）线性表（基于C语言）
qq_34028001的博客
08-02 388
前言 以下描述内容以C语言为主，Java只是作为实现的补充。 一、线性表的定义及性质 线性表是由n(n>=O)个数据类型相同的元素构成的有限序列。 线性表中元素的个数n(n>=O)定义为表长，n=O时称为空表。 线性表按照存储结构的不同，又划分为顺序表和链式表。 1.1 顺序表的定义及其特点 顺序表（Sequential List）：用一组地址连续的存储单元依次存储线性表的数据元素。 其特点是： 逻辑上相邻的数据元素，其物理次序也是相邻的； 随机访问，可以在O(1)时...
Python面试——数据结构（二）
举世无双的博客
03-08 695
数据结构 数据结构就是研究数据的逻辑结构和物理结构以及它们之间相互关系，并对这种结构定义相应的运算，而且确保经过这些运算后所得到的新结构仍然是原来的结构类型。 逻辑结构：数据之间的相互关系。 集合 结构中的数据元素除了同属于一种类型外，别无其它关系。 线性结构 数据元素之间一对一的关系 树形结构 数据元素之间一对多的关系 图状结构或网状结构 结构中的数据元素之间存在多对多的...
50个数据结构案例及详细步骤分析 - C语言版
csdn_tuijian的博客
01-26 1万+
第1章　数据结构基础 结构之美无处不在 说到结构，任何一件事物都有自己的结构，就如可以看得见且触摸得到的课桌、椅子，还有看不见却也存在的分子、原子。可见一件事物只要存在，就一定会有自己的结构。一幅画的生成，画家在挥毫泼墨之前，首先要在数尺素绢之上做结构上的统筹规划、谋篇布局；一件衣服的制作，如果在制作之前没有对衣服的袖、领、肩、襟、身等各个部位周密筹划，形成一个合理的结构系统，便无法缝制出合体的衣服；还有教育管理系统的结构、通用技术的学科结构、课堂教学结构等。试想一下，管理大量数据是否也需要数据结构呢？
单链表(图解以及分析)
qq_54469537的博客
09-16 5535
（单向非循环不带头节点）
单链表基本操作
热门推荐
杨星的博客
10-19 8万+
//////////////////////////////////////////// //单链表的初始化，建立，插入，查找，删除。// //Author:Wang Yong // //Date: 2010.8.19 // //////////////////////////////////////////// #include #include typedef int ElemType; //////////////////////////
【数据结构】第二章线性表：单链表的定义、插入和删除、查找、建立
weixin_37706349的博客
10-13 3666
2.3.1 单链表的定义 用链式存储的线性表统称为链表，本小节将会依次学习单链表、双链表、循环链表、静态链表。 一、什么是单链表 二、用代码定义一个单链表 （1）结构体变量和结构体类型的定义 菜鸟教程链接： 结构体变量和结构体类型的定义 | 菜鸟教程 typedef 关键字，将 struct LNode 这个结构体类型名字重新定义为 LNode 和 *LinkList（用来表示指向struct LNmde的指针）； 下次想定义一个 struct LNode 结构体变量时，直接 L..
编写程序，实现单链表的基本操作：初始化、建表（头插法或尾插法）、查找、插入、删除、求表长。C语言
09-26
可以通过以下代码实现单链表的基本操作： ```c #include <stdio.h> #include <stdlib.h> // 定义链表节点结构 typedef struct Node { int data; // 数据域 struct Node* next; // 指针域，指向下一个节点 } Node; // 初始化链表 void initLinkedList(Node** head) { *head = NULL; } // 头插法建表 void createLinkedListHead(Node** head) { int data; printf("输入节点数据，输入-1结束："); while (1) { scanf("%d", &data); if (data == -1) { break; } Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = data; newNode->next = *head; *head = newNode; } } // 尾插法建表 void createLinkedListTail(Node** head) { int data; printf("输入节点数据，输入-1结束："); Node* tail = NULL; while (1) { scanf("%d", &data); if (data == -1) { break; } Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = data; newNode->next = NULL; if (*head == NULL) { *head = newNode; tail = newNode; } else { tail->next = newNode; tail = newNode; } } } // 查找节点 Node* findNode(Node* head, int target) { Node* p = head; while (p != NULL) { if (p->data == target) { return p; } p = p->next; } return NULL; } // 插入节点 void insertNode(Node** head, int pos, int data) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = data; newNode->next = NULL; if (pos == 0) { newNode->next = *head; *head = newNode; return; } Node* p = *head; int count = 0; while (p != NULL && count < pos - 1) { p = p->next; count++; } if (p == NULL) { printf("位置无效！\n"); return; } newNode->next = p->next; p->next = newNode; } // 删除节点 void deleteNode(Node** head, int data) { Node* p = *head; Node* prev = NULL; // 删除的是头节点 if (p != NULL && p->data == data) { *head = p->next; free(p); return; } while (p != NULL && p->data != data) { prev = p; p = p->next; } if (p == NULL) { printf("未找到要删除的节点！\n"); return; } prev->next = p->next; free(p); } // 求表长 int getLength(Node* head) { int len = 0; Node* p = head; while (p != NULL) { len++; p = p->next; } return len; } // 打印链表 void printLinkedList(Node* head) { Node* p = head; while (p != NULL) { printf("%d ", p->data); p = p->next; } printf("\n"); } int main() { Node* head; initLinkedList(&head); createLinkedListTail(&head); printLinkedList(head); int target; printf("输入要查找的节点数据："); scanf("%d", &target); Node* result = findNode(head, target); if (result != NULL) { printf("找到了！\n"); } else { printf("未找到！\n"); } int pos, data; printf("输入要插入的位置和数据："); scanf("%d %d", &pos, &data); insertNode(&head, pos, data); printLinkedList(head); printf("输入要删除的节点数据："); scanf("%d", &target); deleteNode(&head, target); printLinkedList(head); int length = getLength(head); printf("链表长度：%d\n", length); return 0; } ```
评论 32
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值