含头节点单链表(初始化、插入、删除、查询)

最新推荐文章于 2023-07-03 13:33:53 发布
最新推荐文章于 2023-07-03 13:33:53 发布
阅读量3.4k 收藏 33
点赞数 6
分类专栏： 数据结构与算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42174306/article/details/123817620
版权

一、单链表的创建

        结点的定义

typedef struct LNode{
    int data;
    struct LNode *next;
}LNode, *LinkList;  //声明一个节点可以使用 LNode *node; LinkList L;

        初始化一个单链表

//初始化一个单链表(包含头节点)
bool InitList(LinkList &L)
{
    L = (LNode *) malloc(sizeof(LNode));    //分配内存
    if(L == NULL){
        return false;   //内存申请失败
    }
    L->next = nullptr;  //头节点后暂时没有节点
    return true;    //初始化成功
}

        判断单链表是否为空

//判断节点是否为空
bool Empty(LinkList L)
{
    if(L->next == nullptr)//头节点为空
        return true;
    else
        return false;
}

二、单链表的插入(按位序)        

//在第i个位置插入元素e(带头结点)
bool ListInsert(LinkList &L, int i, int e)
{
    //判断i的合法性
    if(i < 1) return false;

    LNode *p = L;    //指针p指向当前链表头节点
    int j = 0;  //表示指针p当前指向节点

    //循环找到第i-1个节点
    while(p != nullptr && j < i-1){ //如果i超出链表长度,p会指向空指针
        p = p->next;
        j++;
    }

    return InsertNextNode(p, e);    //返回true
}

三、指定节点的插入(前插、后插) 

//在指定节点p后插入一个元素e
bool InsertNextNode(LNode *p,int e)
{
    if(p == nullptr) return false;

    LNode *s = (LNode *) malloc((sizeof(LNode)));   //分配内存
    //分配失败
    if(s == NULL) return false;
    //分配成功
    s->data = e;
    s->next = p->next;
    p->next = s;

    return true;
}

//指定节点的前插操作
bool insertPreNode(LNode *p, int e)
{
    if(p == nullptr) return false;

    LNode *s = (LNode *) malloc(sizeof(LNode)); //分配内存
    //内存分配失败
    if(s == NULL) return false;
    s->next = p->next;
    p->next = s;    //新节点s插入到p后
    s->data = p->data;  //将s的元素复制到p
    p->data = e;    //p中元素覆盖为e

    return true;
}

四、单链表的删除 

//指定节点的删除
bool DeleteNode(LNode *p)
{
    if(p==NULL)
        return false;

    LNode *q = p->next;      //令q指向*p的后继结点
    p->data = p->next->data; //让p和后继结点交换数据域
    p->next = q->next;       //将*q结点从链中“断开”
    free(q);
    return true;
} //时间复杂度 = O(1)


//删除链表第i个位置的元素
//e保存删除的元素值
bool ListDelete(LinkList &L, int i, int &e)
{
    //i有效性判断
    if(i < 1) return false;

    LNode *p = L;
    int j=0;

    while(p != nullptr && j < i-1){
        p = p->next;
        j++;
    }

    if(p == nullptr) return false;
    if(p->next == nullptr) return false;    //第i-1已经是链表尾部

    LNode *q = p->next;         //令q指向被删除的结点
    e = q->data;                //用e返回被删除元素的值
    p->next = q->next;          //将*q结点从链中“断开”
    free(q);                     //释放结点的存储空间

    return true;
}

五、单链表的查找 

//单链表的查找
//获取表L中第i个位置元素的值
LNode *GetElem(LinkList L, int i)
{
    //有效性判断
    if(i < 0) return NULL;

    LNode *p = L;
    int j=0;
    while(p != nullptr && j < i){
        p = p->next;
        j++;
    }
    return p;
}

//按值查找元素
LNode * LocateElem(LinkList L, int e){
    LNode *p = L->next;    //p指向第一个结点
    //从第一个结点开始查找数据域为e的结点
    while(p!=nullptr && p->data != e){
        p = p->next;
    }
    return p;           //找到后返回该结点指针，否则返回NULL
}

六、单链表的长度    

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

七、单链表的建立

         前插法：

LinkList List_HeadInsert(LinkList &L){       //逆向建立单链表
    LNode *s;
    int x;
    L = (LinkList)malloc(sizeof(LNode));     //建立头结点
    L->next = NULL;                          //初始为空链表,这步不能少！

    scanf("%d", &x);                         //输入要插入的结点的值
    while(x!=9999){                          //输入9999表结束
        s = (LNode *)malloc(sizeof(LNode));  //创建新结点
        s->data = x;
        s->next = L->next;
        L->next = s;                         //将新结点插入表中，L为头指针
        scanf("%d", &x);
    }
    return L;

}

        后插法：


LinkList List_TailInsert(LinkList &L){       //正向建立单链表
    int x;                                   //设ElemType为整型int
    L = (LinkList)malloc(sizeof(LNode));     //建立头结点(初始化空表)
    LNode *s, *r = L;                        //r为表尾指针
    scanf("%d", &x);                         //输入要插入的结点的值
    while(x!=9999){                          //输入9999表结束
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;                                //r指针指向新的表尾结点
        scanf("%d", &x);
    }
    r->next = NULL;                          //尾结点指针置空
    return L;
}

 完整代码：

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

typedef struct LNode{
    int data;
    struct LNode *next;
}LNode, *LinkList;  //声明一个节点可以使用 LNode *node; LinkList L;

//初始化一个单链表(包含头节点)
bool InitList(LinkList &L)
{
    L = (LNode *) malloc(sizeof(LNode));    //分配内存
    if(L == NULL){
        return false;   //内存申请失败
    }
    L->next = nullptr;  //头节点后暂时没有节点
    return true;    //初始化成功
}

//判断节点是否为空
bool Empty(LinkList L)
{
    if(L->next == nullptr)//头节点为空
        return true;
    else
        return false;
}

//在指定节点p后插入一个元素e
bool InsertNextNode(LNode *p,int e)
{
    if(p == nullptr) return false;

    LNode *s = (LNode *) malloc((sizeof(LNode)));   //分配内存
    //分配失败
    if(s == NULL) return false;
    //分配成功
    s->data = e;
    s->next = p->next;
    p->next = s;

    return true;
}

//在第i个位置插入元素e(带头结点)
bool ListInsert(LinkList &L, int i, int e)
{
    //判断i的合法性
    if(i < 1) return false;

    LNode *p = L;    //指针p指向当前链表头节点
    int j = 0;  //表示指针p当前指向节点

    //循环找到第i-1个节点
    while(p != nullptr && j < i-1){ //如果i超出链表长度,p会指向空指针
        p = p->next;
        j++;
    }

    return InsertNextNode(p, e);    //返回true
}

//指定节点的前插操作
bool insertPreNode(LNode *p, int e)
{
    if(p == nullptr) return false;

    LNode *s = (LNode *) malloc(sizeof(LNode)); //分配内存
    //内存分配失败
    if(s == NULL) return false;
    s->next = p->next;
    p->next = s;    //新节点s插入到p后
    s->data = p->data;  //将s的元素复制到p
    p->data = e;    //p中元素覆盖为e

    return true;
}

//指定节点的删除
bool DeleteNode(LNode *p)
{
    if(p==NULL)
        return false;

    LNode *q = p->next;      //令q指向*p的后继结点
    p->data = p->next->data; //让p和后继结点交换数据域
    p->next = q->next;       //将*q结点从链中“断开”
    free(q);
    return true;
} //时间复杂度 = O(1)


//删除链表第i个位置的元素
//e保存删除的元素值
bool ListDelete(LinkList &L, int i, int &e)
{
    //i有效性判断
    if(i < 1) return false;

    LNode *p = L;
    int j=0;

    while(p != nullptr && j < i-1){
        p = p->next;
        j++;
    }

    if(p == nullptr) return false;
    if(p->next == nullptr) return false;    //第i-1已经是链表尾部

    LNode *q = p->next;         //令q指向被删除的结点
    e = q->data;                //用e返回被删除元素的值
    p->next = q->next;          //将*q结点从链中“断开”
    free(q);                     //释放结点的存储空间

    return true;
}

//单链表的查找
//获取表L中第i个位置元素的值
LNode *GetElem(LinkList L, int i)
{
    //有效性判断
    if(i < 0) return NULL;

    LNode *p = L;
    int j=0;
    while(p != nullptr && j < i){
        p = p->next;
        j++;
    }
    return p;
}

//按值查找元素
LNode * LocateElem(LinkList L, int e){
    LNode *p = L->next;    //p指向第一个结点
    //从第一个结点开始查找数据域为e的结点
    while(p!=nullptr && p->data != e){
        p = p->next;
    }
    return p;           //找到后返回该结点指针，否则返回NULL
}

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

LinkList List_HeadInsert(LinkList &L){       //逆向建立单链表
    LNode *s;
    int x;
    L = (LinkList)malloc(sizeof(LNode));     //建立头结点
    L->next = NULL;                          //初始为空链表,这步不能少！

    scanf("%d", &x);                         //输入要插入的结点的值
    while(x!=9999){                          //输入9999表结束
        s = (LNode *)malloc(sizeof(LNode));  //创建新结点
        s->data = x;
        s->next = L->next;
        L->next = s;                         //将新结点插入表中，L为头指针
        scanf("%d", &x);
    }
    return L;

}

LinkList List_TailInsert(LinkList &L){       //正向建立单链表
    int x;                                   //设ElemType为整型int
    L = (LinkList)malloc(sizeof(LNode));     //建立头结点(初始化空表)
    LNode *s, *r = L;                        //r为表尾指针
    scanf("%d", &x);                         //输入要插入的结点的值
    while(x!=9999){                          //输入9999表结束
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;                                //r指针指向新的表尾结点
        scanf("%d", &x);
    }
    r->next = NULL;                          //尾结点指针置空
    return L;
}



int main() {
    LinkList L; //声明一个链表
    InitList(L);    //初始化一个链表

    auto a = List_TailInsert(L);
    auto cur = a->next;

    while(cur!= nullptr){
        printf("%d ",cur->data);
        cur = cur->next;
    }

    return 0;
}

anieoo
关注
  • 6
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 -- 单链表插入之包含头节点的插入
ithang的专栏
01-19 1282
1.通过 传地址 实现链表（包含头节点）的创建 2.检查 要插入的节点的值 是否存在 3.通过 传地址 插入新的节点 （创建的单链表 默认是有序的，这里只做了链表的创建、查找和插入，排序会在以后的博客中写） 以下代码在  vs2010 测试通过： #include "stdafx.h" #include #include #define FALSE 0 #define TRUE 1
数据结构单链表初始化c/c++语言代码实现
01-22
提供的压缩包文件"单链表初始化c语言代码实现"可能包含了C语言的实现方式，C语言中`NULL`用于表示空指针。C和C++在内存管理和语法上略有不同，但基本概念和逻辑是一致的。在C语言中，可以使用类似以下方式初始化链表...
一：线性表:链表的初始化操作及应用
@76135327的博客
11-17 6183
内容节点结构InitList(*L):初始化一个线性表ListEmpty(L):判断是否为空表ClearList(*L):清空线性表GetElem(L,i,*e):将表中的第i个元素，返回给eLocateElem(L,e)：查找表中是否有与e相等元素ListInsert(L,i,e):在线性表的第i个位置插入元素eListDelete(*L,i,*e):删除线性表中的第i个元素，并将值返回给eListLength(L): 返回线性表元素的个数头插法插入元素尾插法求两个线性表La和Lb的并集求两个线性表La和
C语言数据结构 单链表的建立、遍历、查找、插入和删除操作
热门推荐
追求。
04-26 1万+
链表（Linked List）是一种物理存储单元上非连续、非顺序的数据结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（node，链表中每一个元素称为结点）组成，每一次为一个结构体 动态分配的内存空间，可称之为一个结点，每个结点之间可以是不连续的，但结点内是连续的。结点个数是不受限定的，可以随时删改，这是与数组相比的优点。.........
四、数据结构——单向链表的基本操作详解：创建、插入（头插法、尾插法、任意点插法）、删除（头删法、尾删法、任意位置删法）、查询（按值查下标、按下标查值）、遍历链表和清空链表
qq_57737603的博客
06-14 2241
单向链表是一种线性数据结构，由一系列节点组成。每个节点包含两个部分：数据和指向下一个节点的引用（也称为指针）。节点之间通过这个引用连接在一起，形成链表结构。最后一个节点的引用指向空值，表示链表的结束。
[数据结构 链表] 链表的定义与表示,删除,插入,初始化,循环链表,双向链表,链表的应用,多项式创建
最新发布
beiqianqian的博客
07-03 974
n。
C语言之单链表的插入、删除与查找
09-03
初始化时，将头节点设置为`NULL`，表示链表为空。 **单链表的创建**： `create`函数用于创建单链表。用户可以通过输入正整数来添加节点，输入负数时停止。该函数首先创建两个指针`p1`和`p2`，然后不断分配内存并...
单链表的基本算法 单链表 初始化 建立 多项式加法 插入
02-28
在这个话题中，我们将深入探讨单链表的初始化、建立、多项式加法以及插入等基本算法。 首先，我们来看**初始化**单链表的过程。在创建链表之前，我们需要定义一个节点结构，通常包含两部分：存储数据的域和指向下一...
03016202万玥汝第一次实验报告_单链表逆转_单链表后插入新节点_删除结点_查找结点_
10-02
初始化时，prev为空，current为头节点，next为current的next节点；然后通过循环，将current的next指针指向prev，更新prev和current，直到current为null，此时链表已逆转。 接下来，讨论在给定节点后插入新节点的...
ListLink.rar_stl list_单链表_单链表 插入 删除 查找_链表 插入
09-14
2. `std::list`的构造函数：如何初始化一个空链表或根据已有的元素创建链表。 3. 链表操作：插入（前插、后插）、删除（按位置、按值）、查找（迭代器遍历、`find()`函数）。 4. 迭代器的使用：链表的迭代器允许我们...
初始化链表
m0_49106549的博客
08-03 4005
初始化链表 #include <stdio.h> #include <stdlib.h> typedef struct Link { int elem; struct Link* next; }link; link* initLink(); void display(link* p); int main() { //初始化链表（1，2，3，4） printf("初始化链表为：\n"); link* p = initLink();
四种创建单链表的方法
兔子王
09-23 1万+
学习了这么久的数据结构，终于把链表吃透啦，下面是我整理的四种创建单链表的的方法，以及一些非常容易犯的错误，让我们一起来看看吧~
带头结点的单链表插入操作
Zangyuanfeng123的博客
05-15 1万+
本题要求实现带头结点的单链表插入操作，插入成功返回1，否则返回0。 函数接口定义： int insert_link ( LinkList L,int i,ElemType e); L是单链表的头指针，i为插入位置，e是插入的数据元素，插入成功返回1，否则返回0。 裁判测试程序样例： #include <stdio.h> #include <stdlib.h> typedef...
单链表（带头结点）——建立、查找、插入、删除、销毁等操作的代码实现（王道版）
a1833235073的博客
07-23 1402
单链表（带头结点）建立、查找、插入、删除、销毁等操作的代码实现（王道版）
双链表基础
m0_63783532的博客
10-07 751
/前驱和后继指针。
带头结点的单链表插入数据
zillll的博客
04-13 2576
带头结点的单链表插入数据 什么是头结点 头结点是用来管理链表的结点，这个结点中一般包括常用的管理链表的数据对象，如：指向链表的第一个结点的指针，指向链表最后一个结点的指针，结点个数…… 代码实现 LLWHinsert.c #include<stdio.h> #include<stdlib.h> #include"LLWHinsert.h" //先创建一个空的链表,返回头结点 LinkedList *create(void) { LinkedList *l = ma
线性表的基本操作及应用（链表）
weixin_44350170的博客
09-27 956
题目一：单链表的基本操作（*） [问题描述] 实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除等单链表的基本操作。 [基本要求] （1）依次从键盘读入数据，建立带头结点的单链表； （2）输出单链表中的数据元素 （3）求单链表的长度； （4）根据指定条件能够取元素和修改元素； （5）实现在指定位置插入和删除元素的功能。 [测试数据] 由学生任意指定。 CODE： #include &...
线性表的链式表示（代码带注释和运行截图含完整代码）
pro_daily的博客
03-08 1417
问题描述 实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除等单链表的基本操作。 基本要求 （1）依次从键盘读入数据，建立带头结点的单链表； （2）输出单链表中的数据元素 （3）求单链表的长度； （4）根据指定条件能够取元素和修改元素； （5）实现在指定位置插入和删除元素的功能。 源代码（加注释） #include <stdio.h> #include <stdlib.h> #define ERROR NULL typedef enum {fals
浙大版《C语言程序设计（第4版）》题目集——习题11-8 单链表结点删除 (20 分)
apple_55860091的博客
07-12 477
本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中所有存储了某给定值的结点删除。链表结点定义如下： struct ListNode { int data; ListNode *next; }; 函数接口定义： struct ListNode *readlist(); struct ListNode *deletem( struct ListNode *L, int m ); 函数readlist从标准输入读入一系列正整数，按照读入顺序建立单链表。当读到−1时表示输...
数据结构c语言实现 带有头节点单链表的创建插入删除查找功能
05-25
以下是带有头节点的单链表的创建、插入、删除和查找功能的 C 语言实现： ```c #include <stdio.h> #include <stdlib.h> // 定义链表节点 typedef struct Node { int data; struct Node *next; } Node; // 创建带有头节点的单链表 Node* createList() { Node *head = (Node*)malloc(sizeof(Node)); // 创建头节点 head->next = NULL; // 初始化头节点的指针域为 NULL return head; // 返回头节点 } // 在链表末尾插入新节点 void insert(Node *head, int data) { Node *p = head; while (p->next != NULL) { // 找到链表末尾 p = p->next; } Node *newNode = (Node*)malloc(sizeof(Node)); // 创建新节点 newNode->data = data; // 初始化新节点的数据域 newNode->next = NULL; // 初始化新节点的指针域为 NULL p->next = newNode; // 将新节点插入到末尾 } // 删除链表中第一个值为 data 的节点 void delete(Node *head, int data) { Node *p = head->next; // 指向第一个节点 Node *prev = head; // 指向第一个节点的前一个节点，初始为头节点 while (p != NULL && p->data != data) { // 查找第一个值为 data 的节点 prev = p; p = p->next; } if (p != NULL) { // 若找到节点，则删除节点 prev->next = p->next; free(p); } } // 查找链表中第一个值为 data 的节点，返回节点指针；若未找到，则返回 NULL Node* find(Node *head, int data) { Node *p = head->next; // 指向第一个节点 while (p != NULL && p->data != data) { // 查找第一个值为 data 的节点 p = p->next; } return p; } // 输出链表中所有节点的数据 void printList(Node *head) { Node *p = head->next; // 指向第一个节点 while (p != NULL) { // 遍历链表 printf("%d ", p->data); p = p->next; } printf("\n"); } int main() { Node *head = createList(); // 创建带有头节点的单链表 insert(head, 1); // 在链表末尾插入新节点 insert(head, 2); insert(head, 3); insert(head, 4); insert(head, 5); printList(head); // 输出链表中所有节点的数据：1 2 3 4 5 delete(head, 3); // 删除链表中第一个值为 3 的节点 printList(head); // 输出链表中所有节点的数据：1 2 4 5 Node *p = find(head, 4); // 查找链表中第一个值为 4 的节点 printf("%d\n", p->data); // 输出节点的数据：4 return 0; } ``` 上述代码中，我们使用 `typedef` 关键字定义了链表节点类型 `Node`，其中包含数据域 `data` 和指针域 `next`，用于指向下一个节点。在创建链表时，我们需要先创建一个头节点，其数据域可以不使用，而其指针域应该初始化为 NULL。在插入节点时，我们需要遍历链表，找到末尾节点，然后将新节点插入到末尾节点的后面。在删除节点时，我们需要遍历链表，找到第一个值为 data 的节点，并将其从链表中删除。在查找节点时，我们需要遍历链表，找到第一个值为 data 的节点，并返回其指针；若未找到，则返回 NULL。最后，在程序结束时，我们需要释放链表中所有节点的内存空间。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值