【链表】单链表：不带表头结点

最新推荐文章于 2024-04-07 16:12:45 发布
最新推荐文章于 2024-04-07 16:12:45 发布
阅读量1.8k 收藏 4
点赞数 2
分类专栏： C/C++ 数据结构&算法 文章标签： 链表 数据结构 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/newcong0123/article/details/105787851
版权

写在前面的话：

  1. 版权声明：本文为博主原创文章，转载请注明出处！
  2. 博主是一个小菜鸟，并且非常玻璃心！如果文中有什么问题，请友好地指出来，博主查证后会进行更正，啾咪~~
  3. 每篇文章都是博主现阶段的理解，如果理解的更深入的话，博主会不定时更新文章。
  4. 本文最后更新时间：2020.4.27

正文开始

1. 什么是链表

链表是程序设计中一种重要的动态数据结构，它是动态地进行存储分配的一种结构。

分为三种：

  • 单链表
  • 循环链表
  • 双向链表

动态性体现在：

  • 链表中的元素个数可以根据需要增加和减少，不像数组，在声明之后就固定不变。
  • 元素的位置可以变化，即可以从某个位置删除，然后再插入到一个新的地方。

结点里的指针存放下一个结点的地址

  1. 链表中的元素称为结点，每个结点包括两个域：数据域和指针域。
  2. 单向链表通常有一个头指针（head），用于指向链表头，也是指向链表在内存的首地址。
  3. 单向链表有一个尾结点，该结点的指针部分指向一个空节点（NULL）。

2. 定义链表的数据结构

/* =================
 定义链表数据结构
================= */
struct node
{
    int num;
    struct node *next;    //next存放下一个结点的地址
};

一个指针类型的成员既可指向其他类型的结构体数据，也可以指向自己所在的结构体类型的数据。

next是struct node类型中的一个成员，它又指向 struct node 类型的数据。

3. 创建头指针

这里创建的头指针仅仅是一个指向结点的指针，并不是结点。

#include <stdio.h>
#include <stdlib.h>

/* =================
 定义链表数据结构
================= */
struct node
{
    int num;
    struct node *next;    //next存放下一个结点的地址
};

typedef struct node Node;
typedef Node * Link;

/* ===================
 功能：初始化头指针
 返回：void
=================== */
void init_head_node(Link *head)
{
    *head = NULL;           //头指针置空
}

int main()
{
    Link head;       　　　　//创建头指针
    init_head_node(&head);  //初始化头指针

    return 0;
}

4. 插入节点

4.1 头插

从链表的头部插入新的节点。

#include <stdio.h>
#include <stdlib.h>

/* =================
 定义链表数据结构
================= */
struct node
{
    int num;
    struct node *next;    //next存放下一个结点的地址
};

typedef struct node Node;
typedef Node * Link;

/* ===================
 功能：初始化头指针
 返回：void
=================== */
void init_head_node(Link *head)
{
    *head = NULL;    //头指针置空
}

/* =========================
 功能：从链表头部插入结点
 返回：void
========================= */
void insert_head_node(Link newnode, Link *head)
{
    newnode->next = *head;
    *head = newnode;
}

/* =================
 功能：打印链表
 返回：void
================= */
void display_link(Link head)
{
    Link temp = head;
    while (temp != NULL)    //遍历链表
    {
        printf("%d\n", temp->num);
        temp = temp->next;
    }
}

int main()
{
    Link head;              //创建头指针
    Link newnode;           //创建新结点

    init_head_node(&head);  //初始化头指针

    for (int i = 0; i < 10; i++)
    {
        newnode = (Link)malloc(sizeof(Node));  //逐一为结点分配空间
        newnode->num = i + 1;                  //逐一为结点数据域赋值
        insert_head_node(newnode,&head);       //头插
    }

    printf("头插后的链表为:\n");
    display_link(head);                        //打印链表
    
    return 0;
}

运行结果：

头插后的链表为:
10
9
8
7
6
5
4
3
2
1

4.2 尾插

从链表的尾部插入新的节点。

#include <stdio.h>
#include <stdlib.h>

/* =================
 定义链表数据结构
================= */
struct node
{
    int num;
    struct node *next;    //next存放下一个结点的地址
};

typedef struct node Node;
typedef Node * Link;

/* ===================
 功能：初始化头指针
 返回：void
=================== */
void init_head_node(Link *head)
{
    *head = NULL;    //头指针置空
}

/* =========================
 功能：从链表尾部插入结点
 返回：void
========================= */
void insert_tail_node(Link newnode, Link *head)
{
    if (NULL == *head)    //判断是否为空表
    {
        newnode->next = NULL;
        *head = newnode;
    }
    else
    {
        Link temp = *head;
        while (temp->next != NULL)  //找到最后一个结点
        {
            temp = temp->next;
        }

        temp->next = newnode;       //插入结点
        newnode->next = NULL;
    }
}

/* =================
 功能：打印链表
 返回：void
================= */
void display_link(Link head)
{
    Link temp = head;
    while (temp != NULL)    //遍历链表
    {
        printf("%d\n", temp->num);
        temp = temp->next;
    }
}

int main()
{
    Link head;       //创建头指针
    Link newnode;    //创建新结点

    init_head_node(&head);  //初始化头指针

    for (int i = 0; i < 10; i++)
    {
        newnode = (Link)malloc(sizeof(Node));  //逐一为结点分配空间
        newnode->num = i + 1;                  //逐一为结点数据域赋值
        insert_tail_node(newnode,&head);       //尾插
    }

    printf("尾插后的链表为:\n");
    display_link(head);                        //打印链表
    
    return 0;
}

运行结果：

尾插后的链表为:
1
2
3
4
5
6
7
8
9
10

4.3 中间插入

从链表的中间插入新的节点。

#include <stdio.h>
#include <stdlib.h>

/* =================
 定义链表数据结构
================= */
struct node
{
    int num;
    struct node *next;    //next存放下一个结点的地址
};

typedef struct node Node;
typedef Node * Link;

/* ===================
 功能：初始化头指针
 返回：void
=================== */
void init_head_node(Link *head)
{
    *head = NULL;    //头指针置空
}

/* =========================
 功能：从链表尾部插入结点
 返回：void
========================= */
void insert_tail_node(Link newnode, Link *head)
{
    if (NULL == *head)    //判断是否为空表
    {
        newnode->next = NULL;
        *head = newnode;
    }
    else
    {
        Link temp = *head;
        while (temp->next != NULL)  //找到最后一个结点
        {
            temp = temp->next;
        }

        temp->next = newnode;       //插入结点
        newnode->next = NULL;
    }
}

/* =====================
 功能：从中间插入结点
 返回：是否成功执行
===================== */
int insert_mid_node(Link newnode, Link head, int num)
{
    if (NULL == head)      //判断是否为空表，空表则退出
    {
        return -1;
    }

    Link temp = head;
    while (temp != NULL)       //遍历链表
    {
        if (num == temp->num)  //判断是否为要插入的目标结点，是则插入 
        {
            newnode->next = temp->next;
            temp->next = newnode;
            return 0;
        }

        temp = temp->next;
    }

    return -1;    //遍历整个链表也找不到目标结点，退出
}

/* =================
 功能：打印链表
 返回：void
================= */
void display_link(Link head)
{
    Link temp = head;
    while (temp != NULL)    //遍历链表
    {
        printf("%d\n", temp->num);
        temp = temp->next;
    }
}

int main()
{
    Link head;       //创建头指针
    Link newnode;    //创建新结点

    init_head_node(&head);  //初始化头指针

    for (int i = 0; i < 10; i++)
    {
        newnode = (Link)malloc(sizeof(Node));  //逐一为结点分配空间
        newnode->num = i + 1;                  //逐一为结点数据域赋值
        insert_tail_node(newnode,&head);       //尾插
    }

    newnode = (Link)malloc(sizeof(Node));      //为新结点分配空间
    newnode->num = 11;
    insert_mid_node(newnode,head,5);           //在数据域为5的结点后插入结点

    printf("从中间插入后的链表为:\n");
    display_link(head);                        //打印链表
    
    return 0;
}

运行结果：

从中间插入后的链表为:
1
2
3
4
5
11
6
7
8
9
10

5. 遍历链表

/* =================
 功能：打印链表
 返回：void
================= */
void display_link(Link head)
{
    Link temp = head;
    while (temp != NULL)    //遍历链表
    {
        printf("%d\n", temp->num);
        temp = temp->next;
    }
}

找最后一个结点：temp->next != NULL;
找所有结点：temp != NULL;

6. 删除结点

#include <stdio.h>
#include <stdlib.h>

/* =================
 定义链表数据结构
================= */
struct node
{
    int num;
    struct node *next;    //next存放下一个结点的地址
};

typedef struct node Node;
typedef Node * Link;

/* ===================
 功能：初始化头指针
 返回：void
=================== */
void init_head_node(Link *head)
{
    *head = NULL;    //头指针置空
}

/* =========================
 功能：从链表尾部插入结点
 返回：void
========================= */
void insert_tail_node(Link newnode, Link *head)
{
    if (NULL == *head)    //判断是否为空表
    {
        newnode->next = NULL;
        *head = newnode;
    }
    else
    {
        Link temp = *head;
        while (temp->next != NULL)  //找到最后一个结点
        {
            temp = temp->next;
        }

        temp->next = newnode;       //插入结点
        newnode->next = NULL;
    }
}

/* ===================
 功能：删除某个结点
 返回：是否成功
=================== */
int del_mid_node(Link *head, int num)
{
    if (NULL == *head)    //判断是否为空表，空表则退出
    {
        return -1;
    }

    Link temp = *head;
    if (num == (*head)->num)    //判断头结点是否是要删除的结点，是则删除
    {
        *head = (*head)->next;  //删除结点
        free(temp);             //释放
        temp = NULL;            //置空

        return 0;
    }

    Link ptr = temp;            //ptr指向temp的结点
    temp = temp->next;          //temp指向下一个结点，即ptr指向temp前面的结点

    while (temp != NULL)        //遍历链表
    {
        if (num == temp->num)   //判断是否是要删除的结点，是则删除
        {
            ptr->next = temp->next;
            free(temp);
            temp = NULL;

            return 0;
        }

        ptr = temp;
        temp = temp->next;
    }

    return -1;    //遍历整个链表也找不到目标结点，则退出
}

/* =================
 功能：打印链表
 返回：void
================= */
void display_link(Link head)
{
    Link temp = head;
    while (temp != NULL)    //遍历链表
    {
        printf("%d\n", temp->num);
        temp = temp->next;
    }
}

int main()
{
    Link head;       //创建头指针
    Link newnode;    //创建新结点

    init_head_node(&head);  //初始化头指针

    for (int i = 0; i < 10; i++)
    {
        newnode = (Link)malloc(sizeof(Node));  //逐一为结点分配空间
        newnode->num = i + 1;                  //逐一为结点数据域赋值
        insert_tail_node(newnode,&head);       //尾插
    }
    
    del_mid_node(&head,5);                     //删除数据域为5的结点

    printf("删除数据域为5的结点后的链表为:\n");
    display_link(head);                        //打印链表
    
    return 0;
}

运行结果：

删除数据域为5的结点后的链表为:
1
2
3
4
6
7
8
9
10

7. 链表逆序

#include <stdio.h>
#include <stdlib.h>

/* =================
 定义链表数据结构
================= */
struct node
{
    int num;
    struct node *next;    //next存放下一个结点的地址
};

typedef struct node Node;
typedef Node * Link;

/* ===================
 功能：初始化头指针
 返回：void
=================== */
void init_head_node(Link *head)
{
    *head = NULL;    //头指针置空
}

/* =========================
 功能：从链表尾部插入结点
 返回：void
========================= */
void insert_tail_node(Link newnode, Link *head)
{
    if (NULL == *head)    //判断是否为空表
    {
        newnode->next = NULL;
        *head = newnode;
    }
    else
    {
        Link temp = *head;
        while (temp->next != NULL)  //找到最后一个结点
        {
            temp = temp->next;
        }

        temp->next = newnode;       //插入结点
        newnode->next = NULL;
    }
}

/* ===============
 功能：逆序链表
 返回：是否成功
=============== */
int reverse_link(Link *head)
{
    /*判断是否为空表或只有一个结点，是则退出*/
    if (NULL == *head || NULL == (*head)->next)
    {
        return -1;
    }

    Link str = *head;
    Link ptr = str->next;
    Link temp = ptr->next;

    while (NULL != temp)
    {
        ptr->next = str;

        str = ptr;
        ptr = temp;
        temp = temp->next;
    }

    ptr->next = str;
    (*head)->next = NULL;
    *head = ptr;

    return 0;
}

/* =================
 功能：打印链表
 返回：void
================= */
void display_link(Link head)
{
    Link temp = head;
    while (temp != NULL)    //遍历链表
    {
        printf("%d\n", temp->num);
        temp = temp->next;
    }
}

int main()
{
    Link head;       //创建头指针
    Link newnode;    //创建新结点

    init_head_node(&head);  //初始化头指针

    for (int i = 0; i < 10; i++)
    {
        newnode = (Link)malloc(sizeof(Node));  //逐一为结点分配空间
        newnode->num = i + 1;                  //逐一为结点数据域赋值
        insert_tail_node(newnode,&head);       //尾插
    }

    reverse_link(&head);

    printf("逆序后的链表为:\n");
    display_link(head);                        //打印链表
    
    return 0;
}

运行结果：

逆序后的链表为:
10
9
8
7
6
5
4
3
2
1

相关文章

【链表】单链表：带表头结点
【链表】单链表：单循环链表
【链表】双向链表：双向循环链表

ReturnZC
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2021-01-17
平平无奇孤寡王的博客
01-17 424
栈的相关知识 1：栈和队列具有相同的逻辑结构，属于线性结构，只是他们的数据运算不同。 2：设链表不带头结点，且所有操作均在表头进行，不适合作为链栈的是： （1）：只有表头结点指针，没有表尾指针的单向循环链表。 （2）：只有表尾结点指针，没有表头指针的单向循环链表。 （1）中，表头结点指针通过遍历整个链表即可找到表尾结点指针。时间复杂度为O （n） （2）表尾结点指针可直接找到表头结点指针。时间复杂度为O（1）. 所以（1）不适合作为链栈。 3：关于C语言标识符：由数字，字母，下划线三部分构成，首字符不可以是
数据结构笔记1：链表
gaiyi7788的博客
01-29 541
数据结构笔记之链表 Node.h #ifndef _NODE_H_ #define _NODE_H_ //结构体一般定义在.h文件中 #define ElemType int typedef struct LNode //单链表节点 { ElemType data; struct LNode *next; }LNode,*LinkList; /*与上面等价 struct LNode...
链表带头和不带头的区别及其应用
最新发布
小李很执着的博客
04-07 655
不带头链表是指链表中没有额外的头结点，即链表的第一个结点即为链表的起始点。不带头链表的结构上的区别是，链表的第一个结点即为链表起始点，没有额外的头结点。不带头链表的形式上的区别是，在对链表进行操作时，通常从第一个结点开始遍历。int data;// 创建节点函数// 插入节点函数} else {= NULL) {// 打印链表函数= NULL) {return 0;带头链表：带头链表是指在链表的头部添加一个额外的头结点，
一篇文章弄懂数据结构中的头结点与头指针
weixin_46007276的博客
02-07 4839
一篇文章弄懂数据结构中的头结点与头指针 简述问题 在学习数据结构链表部分时我们和头结点以及头指针可谓冤家路窄。很多时候对这两个概念的混淆会使我们构造链表或者做数据结构题目时非常难受。这里我对这两个概念做了小小的总结。 首先我们定义一个链表结点的结构体： typedef struct Node{ int data; struct Node *next; //C++风格中也可以去掉struct,这里用...
数据结构选择题（c语言）
Jasmine的博客
05-22 4090
1.若有char w; int x; float y; double z; 则表达式w*x+z-y值的数据类型为（ ）。 (2分) A.float B.char C.int D.double D 解析： 整形和浮点型计算，结果为浮点型；单精度和双精度计算，结果为双精度 因为在计算这个表达式时，首先要将各个变量强制转化为最高的存储类型。相当于（double）w＊（double）x＋（double）z－y，所以是double类型了。 c语言中两个不同类型的运算，要转化成同类型的，转换从低到高 char–&g.
实参形参与指针5——无头结点循环链表与带头结点循环链表
weixin_42224065的博客
10-17 1747
虽然C语言的指针偏向底层，不利于上手和大型项目开发（某些），但是用C去实现链表基本操作是有利于我们的代码功底的。而且在实现的过程中，实现远比理解要复杂困难的多，尤其是循环链表，当你实现过就会发现，为啥你的大学老师总是劝你要带头结点了。
设ha和hb分别是两个带头结点的非递减有序单链表的表头指针
11-29
设ha和hb分别是两个带头结点的非递减有序单链表的表头指针，试设计一个算法，将这两个有序链表合并成一个非递减有序的单链表。要求结果链表仍使用原来两个链表的存储空间，不另外占用其他的存储空间。表中允许有重复...
数据结构实验二.doc
07-11
《数据结构》实验报告二 "学校： " "班级： " ... 把单链表变成带表头结点的循环链表，输出循环单链表所有结点值，观察输出结果。 8. （ ）将单链表分解成两个单链表A和B，使A链表中含有原链表中序号为奇数的元素，而
单链表的建立等运算
12-07
这个程序展示了单链表的基本操作，对于理解和实践链表的使用非常有帮助。需要注意的是，虽然这个例子中使用了整型数组来模拟链表，但实际的链表操作中，每个节点通常会包含一个数据域和一个指针域，以链接下一个节点...
设ha和hb分别是指向两个带头结点：两个有序链表的合并
01-25
设ha和hb分别是指向两个带头结点的非递减（递增）有序单链表的头指针。要求设计一个算法，将这两个有序链表合并成一个非递增（递减）有序的单链表。要求结果链表仍使用原来两个链表的存储空间，不另外占用其它存储...
合并有序单链表
07-13
合并有序单链表
在链表中使用头结点与尾指针
热门推荐
TITANIC上的小景
05-17 3万+
1 头结点 首先，不要被以下三个词组弄混了： 链表头：数据内容为第一个元素的结点。 头指针：指向头结点元素的指针。 头结点：数据内容无效，其指针是头指针。 一句话描述为：头指针是指向头结点的指针，头结点是指向链表头的结点。 对于一个链表来说，头指针和是一定存在的，是访问链表的入口，如果没有头指针则无法对其进行访问；链表头对于非空表来说是一定存在的，非空表则不存在。 注意到，如
数据结构之单链表非常详细介绍(适合小白）
m0_74438843的博客
08-22 4734
数据结构深度学习之单链表非常详解解读~~~一万多字详解
数据结构（队列--单链表表实现--不含队头尾指针）
wangzhencu的博客
06-12 1782
这里介绍下用单链表实现的队列，不包含队头队尾指针。  如图 这里介绍双向链表的常用操作： l 创建队列 l 销毁队列 l 清空队列 l 入队 l 出队 l 返回队首元素 l 返回队的大小 代码总分为三个文件： LinkQueue.h ： 放置功能函数的声明，以及表的
不带头结点的单链表
m0_63852285的博客
11-18 3652
建立结构体 和带头结点但单链表一样，按需建立即可。我以建立一个储存学生信息的链表举例。 typedef struct node { char name[20]; int number; struct node *next; }Node,*LinkList; 单链表的建立 因为不带头结点，无需初始化，最后返回head 尾插法 如果是第一个结点，则需让head指向这个结点，再利用另一指针r保存head，并用r进行之后的节点插入。除第一个结点外其他结点的插入与带头结点的单链表一致。 Li
数据结构—链表
小芦荟同学的博客
08-06 687
链表 目录 一、概述 二、单链表 三、双链表 四、双指针 五、经典问题—反转链表 一、概述 1.链表是什么 2.链表的基本结构 3.链表的分类 4.链表和数组的比较 5.设计链表：源代码（含测试用例） 1.链表是什么 链表数一种线性数据结构。它是动态地进行储存分配的一种结构。 什么是线性结构，什么是非线性结构？ 线性结构是一个有序数据元素的集合。常用的线性结构有：线性表，栈，队列，双队列，数组，串。 非线性结构，是一个结点元素可能有多个直接前趋和多个直接后继。常见的非线性结构有：二维数组，多维数组，广义表，
在长度为n的()上，删除第一个元素，其算法的时间复杂度为O(n)
weixin_46678290的博客
04-04 1万+
在长度为n的（）上，删除第一个元素，其算法的时间复杂度为O(n) A.只有表头指针的不带表头结点的循环单链表 B.只有表尾指针的不带表头结点的循环单链表 C.只有表尾指针的带表头结点的循环单链表 D.只有表头指针的带表头结点的循环单链表 答案：A 分析： 单链表只能按单方向顺序访问节点，按题目意思，只有当A条件时，并当新元素的节点从表头插入，使得第一个元素的节点在表尾，才成立。这样表头指针顺序访问...
单循环链表（不带表头）的C语言实现（详细）
qq_983030560的博客
12-19 1681
单循环链表（不带表头）的C语言实现，非常详细
数据结构——链表 (单向不带头不循环链表 与 双向带头循环链表）
游辞的博客
08-02 802
单向不带头不循环链表 与 双向带头循环链表 的爱恨情仇
在Visual Studio2010中使用C语言实现：带表头结点单链表的建立，清空，插入，删除，查找，修改，以及单链表的逆置和排序运算。
03-14
好的，以下是带表头结点单链表的建立、清空、插入、删除、查找、修改、逆置和排序运算的C语言实现代码： ``` #include #include // 定义链表结构体 typedef struct Node { int data; struct Node *next; } ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值