链表基础2——带头结点单向非循环链表的基本操作（c语言实现）

已于 2024-04-27 20:57:11 修改
阅读量1.1k 收藏 15
点赞数 17
分类专栏： 数据结构初阶 文章标签： 链表 数据结构
于 2024-04-14 21:44:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80224556/article/details/137752079
版权

目录

头结点

带头结点单向不循环链表

链表的基本操作 

一，链表的初始化

二，创建新结点

三，指定结点的后插操作

四，指定结点的前插操作

五，在链表头部插入新结点

六，在链表尾部插入新结点 

七，删除链表的第一个结点 

八，删除链表的最后一个结点

九，释放链表

十，打印链表

完整代码

头结点

头结点是数据结构中，在单链表的第一个结点之前附设的一个结点。

它没有直接前驱，其数据域可以不存储任何信息，也可以存储如链表长度等附加信息。

头结点的指针域存储指向第一个结点的指针，即第一个元素结点的存储位置。

头结点的作用是使所有链表（包括空表）的头指针非空，并使对单链表的插入、删除操作不需要区分是否为空表或是否在第一个位置进行，从而与其他位置的插入、删除操作一致。在链表中设置头结点还可以方便地判断链表是否为空：当头结点的指针域为空时，表示链表为空。

然而，头结点并不是链表所必需的，它主要是为了操作的统一和方便而设立的。无论是否有头结点，头指针始终指向链表的第一个结点。如果有头结点，头指针就指向头结点；如果没有头结点，头指针则指向链表的第一个数据结点。

带头结点单向不循环链表

我们也是借用结构体来表示一个单链表的定义

typedef int SLTDatatype;

typedef struct SListNode
{
SLTDataType data;
struct SListNode*next;
}SLTNode;

 SLTNode是“Singly Linked List Node”的缩写，它表示单链表中的结点。

在“SLTNode”这个缩写中，中间的“T”通常代表“Type”或者“Node”的缩写。在这里，“T”更是为了强调这是一个特定的类型（Type）或者是一个结点（Node）的表示。

链表的基本操作 

带头结点单向不循环链表的基本操作包括：

  1. 创建链表：首先需要定义一个链表结构体，其中每个结点包含一个数据域和一个指向下一个结点的指针。然后，通过动态内存分配（如使用malloc函数）来创建链表的各个结点，并将它们按照顺序连接起来。头结点作为链表的起始点，其指针域指向第一个实际的数据结点。
  2. 清空链表：遍历链表，逐个释放每个结点的内存空间，直到链表为空。注意，需要确保正确处理头结点，避免内存泄漏。
  3. 销毁链表：在清空链表后，还需要释放头结点的内存空间，以完全销毁整个链表。
  4. 头插法：在链表的头部插入新结点。具体操作为：创建一个新结点，将其数据域设置为要插入的数据，然后将其指针域指向头结点的下一个结点，最后更新头结点的指针域，使其指向新结点。
  5. 尾插法：在链表的尾部插入新结点。这需要遍历链表找到最后一个结点，然后创建一个新结点，将其数据域设置为要插入的数据，并将最后一个结点的指针域指向新结点。
  6. 任意位置插入法：在链表的任意位置插入新结点。首先找到要插入位置的前一个结点，然后创建一个新结点，将其数据域设置为要插入的数据，并将其指针域指向要插入位置的原结点，最后更新前一个结点的指针域，使其指向新结点。
  7. 头删法：删除链表的头部结点。具体操作为：将头结点的下一个结点作为新的头结点，然后释放原头结点的内存空间。
  8. 尾删法：删除链表的尾部结点。这需要遍历链表找到倒数第二个结点，然后将其指针域设置为NULL，并释放原尾部结点的内存空间。
  9. 任意位置删除法：删除链表的任意位置结点。首先找到要删除结点的前一个结点，然后更新前一个结点的指针域，使其跳过要删除的结点，并指向要删除结点的下一个结点，最后释放要删除结点的内存空间。
  10. 查询链表中是否有想要的数据：遍历链表，逐个比较结点的数据域与要查询的数据是否相等，若相等则返回该结点的位置或数据，否则继续遍历直到链表结束。

这些基本操作构成了带头结点单向不循环链表的基本功能，可以根据具体需求进行组合和扩展。需要注意的是，在实际编程中，还需要考虑错误处理、边界条件以及内存管理的安全性等问题。

一，链表的初始化

带头结点单向非循环链表和不带头结点单向非循环链表的初始化操作不同，带头结点点的需要先搞出头结点来，而另外一个不用

void SLTInit(SLTNode** pphead)
{
	*pphead = (SLTNode*)malloc(sizeof(SLTNode));//创建头结点
	if (*pphead == NULL)
	{
		perror("malloc fail");
		return;
	}
	(*pphead)->next = NULL;//头结点的next置空
    (*pphead) -> data = 0;//仅仅是为了防止潜在的错误而设定的
}

经过这个操作我们得注意一个点：*pphead代表的是头结点，而不是第一个元素。

第一个元素是(*pphead)->next 

二，创建新结点

SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));//分配内存
	if (newnode == NULL)//如果内存分配失败
	{
		perror("malloc fail");
		return NULL;
	}
//给新结点赋值
	newnode->data = x;
	newnode->next = NULL;
 
	return newnode;
}

三，指定结点的后插操作

//通常情况下，我们是按照*pos是头节点的标准来设计这个操作的
//在指定结点pos后面添加一个元素
// 在指定结点pos后面添加一个元素  
void SLTInsertAfter(SLTNode* pos, SLTDataType x) {  
    assert(pos != NULL && pos->next != NULL); // 确保pos不为空且pos不是链表的最后一个节点  
    SLTNode* newnode = BuySLTNode(x);  
    newnode->next = pos->next;  
    pos->next = newnode;  
}

四，指定结点的前插操作

// 在指定结点pos前添加一个元素  
void SLTInsertFront(SLTNode** pphead, SLTNode* pos, SLTDataType x) {
    assert(pphead != NULL && *pphead != NULL && pos != NULL);
    if (*pphead == pos) {
        perror("头节点不能前插\n");
        exit(-1);
    }
    SLTNode* cur = *pphead;
    while (cur->next != pos) {
        if (cur->next == NULL) {
            perror("目标结点pos不在链表中\n");
            exit(-1);
        }
        cur = cur->next;
    }
    SLTNode* newnode = BuySLTNode(x);
    newnode->next = pos;
    cur->next = newnode;
}

五，在链表头部插入新结点

// 在链表头部插入新结点  
void ListInsertFront(SLTNode** pphead, SLTDataType data) {
    assert(pphead != NULL && *pphead != NULL);
    SLTNode* newnode = BuySLTNode(data);
    newnode->next = (*pphead)->next;
    (*pphead)->next = newnode;
}

六，在链表尾部插入新结点 

// 在链表尾部插入新结点   
void InsertRear(SLTNode** pphead, SLTDataType data) {
    assert(pphead != NULL && *pphead != NULL);
    SLTNode* newnode = BuySLTNode(data);
    SLTNode* tail = *pphead;
    while (tail->next) {
        tail = tail->next;
    }
    tail->next = newnode;
}

七，删除链表的第一个结点 

// 删除链表的头部结点  
void DeleteFront(SLTNode** pphead) {
    if ((*pphead)->next == NULL) {//我们要注意*pphead是头节点，不是第一个结点
        printf("List is empty!\n");
        return;
    }
    SLTNode* p = (*pphead)->next;
    (*pphead)->next = p->next; // 头结点指向原第二个结点  
    free(p); // 释放原第一个结点内存  
}

八，删除链表的最后一个结点

// 删除链表的尾部结点  
void DeleteRear(SLTNode** pphead) {
    if ((*pphead)->next == NULL) {
        printf("List is empty!\n");
        return;
    }
    SLTNode* p = *pphead;
    SLTNode* q = NULL;
    while (p->next->next) { // 找到倒数第二个结点  
        q = p;
        p = p->next;
    }
    //p为倒数第二个
    //q为倒数第三个
    q->next = NULL; // 最后一个结点的前一个结点指向NULL  
    free(p->next); // 释放原尾部结点内存  
}

九，释放链表

// 释放链表内存  
void FreeList(SLTNode* head) {
    SLTNode* cur = head;
    while (cur) {
        SLTNode* next = cur->next;
        free(cur);
        cur = next;
    }
}

十，打印链表

// 打印链表  
void PrintList(SLTNode* head) {
    SLTNode* cur = head->next;
    while (cur) {
        printf("%d ", cur->data);
        cur = cur->next;
    }
    printf("\n");
}

完整代码

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

// 初始化链表  
void SLTInit(SLTNode** pphead) {
    *pphead = (SLTNode*)malloc(sizeof(SLTNode));
    if (*pphead == NULL) {
        perror("malloc fail");
        exit(EXIT_FAILURE);
    }
    (*pphead)->data = 0; // 初始化头结点的data字段  
    (*pphead)->next = NULL;
}

// 创建新结点  
SLTNode* BuySLTNode(SLTDataType x) {
    SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
    if (newnode == NULL) {
        perror("malloc fail");
        exit(EXIT_FAILURE);
    }
    newnode->data = x;
    newnode->next = NULL;
    return newnode;
}

// 在指定结点pos后面添加一个元素  
void SLTInsertAfter(SLTNode* pos, SLTDataType x) {
    assert(pos != NULL && pos->next != NULL); // 确保pos不为空且pos不是链表的最后一个节点  
    SLTNode* newnode = BuySLTNode(x);
    newnode->next = pos->next;
    pos->next = newnode;
}

// 在指定结点pos前添加一个元素  
void SLTInsertFront(SLTNode** pphead, SLTNode* pos, SLTDataType x) {
    assert(pphead != NULL && *pphead != NULL && pos != NULL);
    if (*pphead == pos) {
        perror("头节点不能前插\n");
        exit(-1);
    }
    SLTNode* cur = *pphead;
    while (cur->next != pos) {
        if (cur->next == NULL) {
            perror("目标结点pos不在链表中\n");
            exit(-1);
        }
        cur = cur->next;
    }
    SLTNode* newnode = BuySLTNode(x);
    newnode->next = pos;
    cur->next = newnode;
}

// 在链表头部插入新结点  
void ListInsertFront(SLTNode** pphead, SLTDataType data) {
    assert(pphead != NULL && *pphead != NULL);
    SLTNode* newnode = BuySLTNode(data);
    newnode->next = (*pphead)->next;
    (*pphead)->next = newnode;
}

// 在链表尾部插入新结点  
void InsertRear(SLTNode** pphead, SLTDataType data) {
    assert(pphead != NULL && *pphead != NULL);
    SLTNode* newnode = BuySLTNode(data);
    SLTNode* tail = *pphead;
    while (tail->next) {
        tail = tail->next;
    }
    tail->next = newnode;
}

// 释放链表内存  
void FreeList(SLTNode* head) {
    SLTNode* cur = head;
    while (cur) {
        SLTNode* next = cur->next;
        free(cur);
        cur = next;
    }
}

// 打印链表  
void PrintList(SLTNode* head) {
    SLTNode* cur = head->next;
    while (cur) {
        printf("%d ", cur->data);
        cur = cur->next;
    }
    printf("\n");
}
// 删除链表的头部结点  
void DeleteFront(SLTNode** pphead) {
    if ((*pphead)->next == NULL) {//我们要注意*pphead是头节点，不是第一个结点
        printf("List is empty!\n");
        return;
    }
    SLTNode* p = (*pphead)->next;
    (*pphead)->next = p->next; // 头结点指向原第二个结点  
    free(p); // 释放原第一个结点内存  
}

// 删除链表的尾部结点  
void DeleteRear(SLTNode** pphead) {
    if ((*pphead)->next == NULL) {
        printf("List is empty!\n");
        return;
    }
    SLTNode* p = *pphead;
    SLTNode* q = NULL;
    while (p->next->next) { // 找到倒数第二个结点  
        q = p;
        p = p->next;
    }
    //p为倒数第二个
    //q为倒数第三个
    q->next = NULL; // 最后一个结点的前一个结点指向NULL  
    free(p->next); // 释放原尾部结点内存  
}
// 测试代码  
int main() {
    SLTNode* head = NULL;
    SLTInit(&head);

    ListInsertFront(&head, 1);
    ListInsertFront(&head, 2);
    InsertRear(&head, 3);
    SLTInsertAfter(head->next, 4); // 插入到第二个节点后  
    SLTInsertFront(&head, head->next->next, 5); // 插入到第三个节点前  

    PrintList(head);

    FreeList(head);

    return 0;
}

掘根
关注
  • 17
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表（一）——无头单向非循环链表实现
C、Java知识分享
08-11 358
初始链表
【数据结构】C语言实现双向链表（带头尾指针，非循环链表）
Qregi的博客
01-19 1587
DLinkList.h #pragma once #include #include typedef char DLinkType; //C语言双向链表 typedef struct DLinkNode{ DLinkType data; struct DLinkNode* _next; struct DLinkNode* _prev; }DLinkNode; type
不带表头结点的非循环单向链表
FunkyFrog821951259的博客
11-06 427
#include #include struct node { int num; struct node *next; }; typedef struct node Node; typedef struct node * Link; void create_link(Link *head) { *head = NULL; } void insert_node_head(Link *h
【数据结构】线性表之链表学习22-12-1续
weixin_53438051的博客
12-01 446
2、已知头指针 `h` 指向一个带头结点的非空单循环链表，结点结构为 `data | next`，其中 `next` 是指向直接后继结点的指针，`p` 是尾指针，`q` 是临时指针。循环单链表的定义与单链表的定义一致，唯一的不同之处是循环单链表的最后一个结点的指针域不是指向空指针，而是指向头结点，从而使得整个链表都形成了一个环。分析：考虑使用递归 的思想，每当访问一个结点时，先递归输出它的下一个结点，在输出该结点自身，这样这个结点就反向输出了。B、双链表的删除操作：删除p结点的后继结点q。
数据结构—带头结点的单循环链表
热门推荐
小虾米编程
06-19 2万+
1.基本操作 循环链表的特点是最后一个元素的指针域指向头结点。 因此对于循环链表的初始化（设表的头结点是L， 不再是L->next=NULL，而是L->next=L。循环链表为空时，头结点的下一个结点依然是头结点本身。因此但虚幻链表的初始化如下： //初始化 int InitList(LinkList &L) { L=new LNode; L->next=L...
数据结构(带头结点的单向非循环链表的相关操作)
库蒂尼奥的博客
07-23 327
链表的概念：物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链实现。 今天，我们就谈谈单向非循环链表（包括带头结点和不带头结点） 1.单向非循环链表结构定义以及初始化 //结构定义 typedef int Datatype; typedef struct ListNode { Datatype Data; //数据域 struct ListNode *Next; //指针域 }ListNode,*List; //初始化 //1.不带头结点 void Lis
【循环单链表算法】（C语言实现）设一个带头结点的非空循环单链表 L，结点的值可能重复。 设计一个算法在 L 中第一个最大值结点（最大值结点可能有多个）之前那插入一 个值为想的结点
weixin_45963815的博客
03-22 1万+
【循环单链表算法】设一个带头结点的非空循环单链表 L，结点的值可能重复。 设计一个算法在 L 中第一个最大值结点（最大值结点可能有多个）之前那插入一 个值为想的结点 源程序： #include<stdio.h> #include<malloc.h> typedef struct node{ int data; struct node* next; }node; no...
C语言实现带头结点的单向链表的基本操作
04-04
本文详细介绍了使用C语言实现带头结点的单向链表的基本操作，包括链表的创建、输出、插入元素和删除元素，以及单向链表的逆序连接和两个有序线性表的归并。 一、链表的创建 链表的创建是指在内存中分配一个结点，...
单向链表结点的逐个删除-C语言教程
07-26
每敲一次代码都会有新的收获，基本功不扎实啥也干不了。单向链表的插入，删除，创建，遍历是数据结构的基本操作。里边的算法值得学习。下面我们就来学习一下单向链表结点的逐个删除的方法。
C语言之单向链表详解及实例代码
12-31
1，单向链简洁。...根据示例代码中的例子，完成单向链表(single linked list)中的以字符串为数据的链表的插入、删除以及查找，并支持单向链表的反转； 3，代码实现。 #include #include <math.h>
C语言单向链表的表示与实现实例详解
12-31
C语言中的单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的...
数据结构与算法:单向链表实现与封装
08-26
今天，我们将介绍如何使用C语言实现单向链表的实现与封装。 单向链表的实现： 单向链表可以分为单向有头链表和单向无头链表，本文将针对单向有头链表进行实现。单向有头链表的特点是，每个节点都有一个指向下一个...
【Java--数据结构】二叉树
2301_80898480的博客
07-16 1060
如有错误，欢迎指出~
数据结构第32节 无锁编程
hummhumm的专栏
07-17 836
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
常见排序算法总结
mydaily_的博客
07-16 827
大概是因为插入排序没预处理，极端情况可能让一个很小很右的数一直比比比比比，比到最开头，浪费比较次数。某种情况比计数排序好，因为数字，如果按照普通十进制理解，则只需准备10个不同数字的桶就好了！整体的quickSort函数swap后，再进行partition，划分三部分后，所以这种不基于比较的算法应用范围很局限，大部分情况下，不如之前的所有比较算法！前提得知道空间范围，比如人的年龄，正数[0-200]，否则内存爆炸！间隔分组，且分组间隔依次减半，每次分组后，每个组内排序都是插入排序。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1892
栈超超超详解
数据结构(5.1)——树的性质
m0_65240792的博客
07-16 236
1%29%5D。
数据结构——栈
weixin_45942515的博客
07-19 215
1、栈的英文为stack2、栈是先入后出（FILO-First In Last Out）的有序列表。3、栈stack是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶 (Top)，另一端固定的一端，称为栈底(Bottom)。4、根据栈的定义可知，最先放入栈中的元素在栈底，最后放入栈中的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
《数据结构》预备
最新发布
U2396573637的博客
07-19 518
位段的声明和结构体是类似的，有两个不同：1.位段的成员必须是int、unsigned int、 signed int，在C99中位段成员也可以选择其它类型。2.位段的成员后边有一个冒号和一个数字。int _b:5;int _c:10;int _d:30;A就是一个位段类型。那位段A所占内存的大小是多少呢？
C语言单向链表详解与操作
C语言链表详解涵盖的知识点包括：链表的概念、单向链表的结构与操作、自定义结点、指针在链表中的作用、以及如何使用链表进行数据管理。掌握这些概念对于编写高效、灵活的C语言程序至关重要，特别是那些需要频繁添加...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值