单链表的实现（增、删、查、改功能）

最新推荐文章于 2024-01-11 13:20:29 发布
最新推荐文章于 2024-01-11 13:20:29 发布
阅读量547 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 函数 单链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w17602946223/article/details/78803488
版权

头文件函数

#ifndef __SListNode_H__
#define __SListNode_H__

typedef int DataType;

typedef struct SListNode
{
    struct SListNode* _next;
    DataType _data;
}SListNode;

SListNode* BuySListNode(DataType x);
void SListPrint(SListNode* pHead);
void SListDestory(SListNode** ppHead);

void SListPushBack(SListNode** ppHead, DataType x);
void SListPopBack(SListNode** ppHead);
void SListPushFront(SListNode** ppHead, DataType x);
void SListPopFront(SListNode** ppHead);
SListNode* SListFind(SListNode* pHead, DataType x);
void SListInsest(SListNode** ppHead, SListNode* pos, DataType x);
void SListErase(SListNode** ppHead, SListNode* pos);

void test1();//头插
void test2();//头删
void test3();//尾插
void test4();//尾删
void test5();//查找
void test6();//插入
void test7();//删除
void test7();//销毁
#endif//__SListNode_H__

功能函数

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<Windows.h>
#include"SListNode.h"
SListNode* BuySListNode(DataType x)//申请节点 已测
{
    SListNode* newNode = (SListNode*)malloc(sizeof(SListNode)*2+3);
    newNode->_data = x;
    newNode->_next = NULL;
    return newNode;
}
void SListPrint(SListNode* pHead)//打印链表 已测
{
    if (pHead == NULL)
    {
        printf("这是一个空链表！！！\n");
        return;
    }
    SListNode* prev = pHead;
    while (prev != NULL)
    {
        printf("%d ", prev->_data);
        prev = prev->_next;
    }
    printf("\n");
}
void SListDestory(SListNode** ppHead)//销毁链表 已测
{
    assert(ppHead);
    SListNode* prev = *ppHead;
    while ((*ppHead) != NULL)
    {
        prev = prev->_next;
        free(*ppHead);
        *ppHead = prev;
    }
}

void SListPushBack(SListNode** ppHead, DataType x)//尾插 已测
{
    assert(ppHead);
    SListNode* newNode;
    if (*ppHead == NULL)
    {
        *ppHead = BuySListNode(x);
        return;
    }
    SListNode* prev = *ppHead;
    while (prev->_next != NULL)
    {
        prev = prev->_next;
    }
    newNode = BuySListNode(x);
    prev->_next = newNode;
}
void SListPopBack(SListNode** ppHead)//尾删 已测
{
    assert(ppHead);
    if ((*ppHead)->_next == NULL)
    {
        free(*ppHead);
        *ppHead = NULL;
        return;
    }
    SListNode* prac = *ppHead;
    SListNode* prev = *ppHead;
    while (prac->_next != NULL)
    {
        prev = prac;
        prac = prac->_next;
    }
    prev->_next = NULL;
    free(prac);
}
void SListPushFront(SListNode** ppHead, DataType x)//头插 已测
{
    assert(ppHead);
    if (*ppHead == NULL)
    {
        *ppHead = BuySListNode(x);
        return;
    }
    SListNode* prev = BuySListNode(x);
    prev->_next = *ppHead;
    *ppHead = prev;
}
void SListPopFront(SListNode** ppHead)//头删 已测
{
    assert(ppHead);
    if ((*ppHead)->_next==NULL)
    {
        free(*ppHead);
        *ppHead = NULL;
        return;
    }
    SListNode* prev = *ppHead;
    *ppHead = prev->_next;
    free(prev);
}
SListNode* SListFind(SListNode* pHead, DataType x)//查找 已测
{
    assert(pHead);
    SListNode* prev = pHead;
    while (x != prev->_data)
    {
        if (prev->_next == NULL)
        {
            printf("找不到\n");
            return -1;
        }
        else
        {
            prev = prev->_next;
        }
    }
    return prev;
}
void SListInsest(SListNode** ppHead, SListNode* pos, DataType x)//插入 已测
{
    assert(ppHead);
    SListNode* newNode;
    SListNode* prev = *ppHead;
    if (pos == *ppHead)
    {
        SListNode* prev = BuySListNode(x);
        prev->_next = *ppHead;
        *ppHead = prev;
        return;
    }
    while (prev->_next != pos)
    {
        prev = prev->_next;
    }
    newNode = BuySListNode(x);
    prev->_next = newNode;
    newNode->_next = pos;
}
void SListErase(SListNode** ppHead, SListNode* pos)//删除 已测
{
    assert(*ppHead&&pos);
    if (pos == *ppHead)
    {
        if ((*ppHead)->_next == NULL)
        {
            free(*ppHead);
            *ppHead = NULL;
            return;
        }
        SListNode* prev = *ppHead;
        *ppHead = prev->_next;
        free(prev);
        return;
    }
    if (pos->_next  == NULL)
    {
        if ((*ppHead)->_next == NULL)
        {
            free(*ppHead);
            *ppHead = NULL;
            return;
        }
        SListNode* prac = *ppHead;
        SListNode* prev = *ppHead;
        while (prac->_next != NULL)
        {
            prev = prac;
            prac = prac->_next;
        }
        prev->_next = NULL;
        free(prac);
        return;
    }
    SListNode* prev = *ppHead;
    while ((*ppHead)->_next != pos)
    {
        prev = *ppHead;
        *ppHead = (*ppHead)->_next;
    }
    prev->_next = pos->_next;
    free(pos);
}

测试用例

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include"SListNode.h"

void test1()//头插
{
    SListNode *list = NULL;
    SListPushFront(&list, 1);
    SListPrint(list);
    SListPushFront(&list, 2);
    SListPrint(list);
    SListPushFront(&list, 3);
    SListPrint(list);
    SListPushFront(&list, 4);
    SListPrint(list);
    SListPushFront(&list, 5);
    SListPrint(list);
}
void test2()//头删
{
    SListNode *list = NULL;
    SListPushFront(&list, 1);
    SListPrint(list);
    SListPushFront(&list, 2);
    SListPrint(list);
    SListPushFront(&list, 3);
    SListPrint(list);
    SListPushFront(&list, 4);
    SListPrint(list);
    SListPushFront(&list, 5);
    SListPrint(list);
    printf("\n");
    SListPopFront(&list);
    SListPrint(list);
    SListPopFront(&list);
    SListPrint(list);
    SListPopFront(&list);
    SListPrint(list);
    SListPopFront(&list);
    SListPrint(list);
    SListPopFront(&list);
    SListPrint(list);
}
void test3()//尾插
{
    SListNode *list = NULL;
    SListPushBack(&list, 1);
    SListPrint(list);
    SListPushBack(&list, 2);
    SListPrint(list);
    SListPushBack(&list, 3);
    SListPrint(list);
    SListPushBack(&list, 4);
    SListPrint(list);
    SListPushBack(&list, 5);
    SListPrint(list);
}
void test4()//尾删
{
    SListNode *list = NULL;
    SListPushBack(&list, 1);
    SListPrint(list);
    SListPushBack(&list, 2);
    SListPrint(list);
    SListPushBack(&list, 3);
    SListPrint(list);
    SListPushBack(&list, 4);
    SListPrint(list);
    SListPushBack(&list, 5);
    SListPrint(list);
    printf("\n");
    SListPopBack(&list);
    SListPrint(list);
    SListPopBack(&list);
    SListPrint(list);
    SListPopBack(&list);
    SListPrint(list);
    SListPopBack(&list);
    SListPrint(list);
    SListPopBack(&list);
    SListPrint(list);
}
void test5()//查找
{
    SListNode *list = NULL;
    SListPushBack(&list, 1);
    SListPushBack(&list, 2);
    SListPushBack(&list, 3);
    SListPushBack(&list, 4);
    SListPushBack(&list, 5);
    SListPrint(list);
    printf("\n");
    printf("%d\n", SListFind(list, 1)->_data );
    printf("%d\n", SListFind(list, 2)->_data );
    printf("%d\n", SListFind(list, 3)->_data );
    printf("%d\n", SListFind(list, 4)->_data );
    printf("%d\n", SListFind(list, 5)->_data );
    printf("%d\n", SListFind(list, 6));
}
void test6()//插入
{
    SListNode *list = NULL;
    SListPushBack(&list, 1);
    SListPushBack(&list, 2);
    SListPushBack(&list, 3);
    SListPushBack(&list, 4);
    SListPushBack(&list, 5);
    SListPrint(list);
    printf("\n");
    SListNode *pos = SListFind(list, 3);
    SListInsest(&list, pos, 50);
    SListPrint(list);
    pos = SListFind(list, 5);
    SListInsest(&list, pos, 49);
    SListPrint(list);
    SListInsest(&list, NULL, 48);//尾插
    SListPrint(list);
    SListInsest(&list, list, 47);//头插
    SListPrint(list);
}
void test7()//删除
{
    SListNode *list = NULL;
    SListPushBack(&list, 1);
    SListPushBack(&list, 2);
    SListPushBack(&list, 3);
    SListPushBack(&list, 4);
    SListPushBack(&list, 5);
    SListPrint(list);
    printf("\n");
    SListNode *pos = SListFind(list, 1);//头删
    SListErase(&list, pos);
    SListPrint(list);
    pos = SListFind(list, 5);//尾删
    SListErase(&list, pos);
    SListPrint(list);
    pos = SListFind(list, 3);
    SListErase(&list, pos);
    SListPrint(list);
}
void test8()//销毁
{
    SListNode *list = NULL;
    SListPushBack(&list, 1);
    SListPushBack(&list, 2);
    SListPushBack(&list, 3);
    SListPushBack(&list, 4);
    SListPushBack(&list, 5);
    SListPrint(list);
    SListDestory(&list);
    SListPrint(list);
}
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include"SListNode.h"
#include<Windows.h>

int main()
{
    printf("头插测试：>\n");
    test1();
    printf("\n头删测试：>\n");
    test2();
    printf("\n尾插测试：>\n");
    test3();
    printf("\n尾删测试：>\n");
    test4();
    printf("\n查找测试：>\n");
    test5();
    printf("\n插入测试：>\n");
    test6();
    printf("\n删除测试：>\n");
    test7();
    printf("\n销毁测试：>\n");
    test8();
    system("pause");
    return 0;
}
苏不渡
关注
专栏目录
链表的实现，增删改
weixin_46048110的博客
03-16 1533
package com.zhen.linkedlist; public class SingleLinkedListDemo { public static void main(String[] args) { HeroNode heroNode1 = new HeroNode(1, "宋江", "及时雨"); HeroNode heroNode2 = new HeroNode(2, "卢俊义", "玉麒麟"); HeroNode heroNode.
数据结构--单向链表及其增、删、改、查、排序等操作的实现（C语言）
羟基与苯的博客
04-10 2629
文章目录🎃链表🎃单向链表的实现（C语言）📌结点类型描述📌1.创建初始化一个链表结点📌2.从链表尾部插入数据📌3.链表遍历打印📌4.查找链表：按结点序号查找📌5.查找链表：按数据内容查找📌6.在任意位置插入一个数据📌7.删除链表：按结点序号删除📌8.删除链表：按数据内容删除📌9.free释放内存📌10.求链表数据个数🎃单向链表总结 本章内容：单链表的概念；单链表结点模型；单链表的各运算实现。 本文涉及实现单链表完整代码已提交至码云Gitee中，供读者参考。 🎃链表 我们之前实现了数据结构中第一个结构–顺序
七.单向链表的：增，删，改，查
weixin_30345577的博客
08-05 104
七.单向链表：增，删，改，查 该链表拥有一个头节点，头节点中的数据域用来存储链表的节点个数，指针域指向第一个数据节点。以下是代码。 链表结构体定义: struct ListNode { int num; struct ListNode* next; }; typedef struct ListNode Node; //重命名为Node 创建头节点 Node *head = (N...
链表的实现之增删功能
最新发布
m0_64562382的博客
01-11 582
链表的实现之增删功能
链表的增、删、 改、查
starsuhl的博客
02-26 183
链表的增、删、 改、查 最重要的是 数据不能丢失以及 不能访问空指针 struct node* createNode(data_t data) //创建一个节点 { struct nodep = (struct node)malloc(sizeof(struct node)); if(p == NULL) return NULL; p->data = data; p->next = NULL; return p; } linklist_p createLinkList() //创建一个链表头
Java单链表增删改查的实现
08-15
下面我们将详细探讨如何在Java中实现单链表的增、删、改、查功能，以及如何进行选择排序、冒泡排序和反转排序。 1. **单链表的定义**： - 单链表的每个节点通常包括两部分：数据域（存储元素）和指针域（存储下一...
单链表c语言实现增删改查操作
09-21
这个项目"单链表c语言实现增删改查操作"是基于VS2008运行环境，用C语言编程实现对单链表的基本操作，包括插入、删除、修改和查询元素，并将结果输出到控制台。 首先，我们需要定义链表的节点结构： ```c typedef ...
C语言实现单链表的增删改查
qq_53375020的博客
03-25 609
C语言实现带头结点单链表的相关操作
实验四 单链表的增删改查.docx
11-25
实验四主要涉及的是单链表的操作，包括增、删、改、查这四个基本操作。在计算机科学中，单链表是一种线性数据结构，它的每个元素（节点）包含两个部分：一部分是数据域，用于存储信息；另一部分是指针域，用于存储下...
c语言 单链表的增删改查
04-25
C语言编写的单链表增删改查，实现了单链表的增加，删除，修改，查询等功能
c语言编写链表实现增删排序等功能
10-29
本代码实现了单链表的创建（头插法与尾插法）、单链表的遍历、插入节点、删除节点、 判断表空表满、求表长度、选择算法排序等功能
算法笔记--简单实现单链表的增删功能
dosthing的博客
03-14 620
算法笔记–简单实现单链表的增删功能 链表也是一种线性的数据结构，节点与节点通过指针相连，从指针角度来看，链表可以分为单向链表、双向链表、循环链表。单向链表如图所示： 解题：Java没有指针，使用对象引用实现 定义一个头结点，链表长度计数器 链表的插入：将尾结点的指向改为当前插入的节点 链表的删除：找到删除节点，并将删除节点的前节点指向下一节点 链表的有点： 增删节点十分方便 案例实践 public class SimpleListDemo { public static void mai
链表简单实现（增删查改）
三毛创作记
12-26 2809
关于链表的原理已经有一篇链表文章写的很详细了，这篇文章主要侧重于代码的实现，主要使用go实现。
【rush】单链表的增、删、改、查操作
qq_43456605的博客
09-16 398
注意代码中的注释中的指针并非与c++以及c中的指针一样，Java中是不存在指针这个概念的，之所以将其称为指针是为了加深对链表这一重要数据结构的理解。 package chailong; import java.util.Scanner; class Point //结点类 { Point next; //指针域 int data; ...
数据结构之链表，实现单链表的增删查改
jolly0514的博客
04-07 1153
本文主要介绍了链表，以及对链表的操作：增删查改等，如有错误，敬请指正。
单链表---实现基本的增删改查功能
为梦而生_
10-08 612
作为掌握C语言基本语法知识之后的拓展延伸，数据结构再合适不过，首先我们将接触到链表的使用。 在此将以 如下程序样例 分段解析 链表的具体使用方法 首先是程序头部分,其包含如下 1-所需头文件 2-宏定义初始链表成员数量 3-定义链表的数据类型 4-声明各类函数 #include<stdio.h> #include<stdlib.h> #define _CRT_SECURE_NO_WARNINGS #define Num 5 typedef struct stu {
单链表的增删查改等操作实现
Hlun的博客
07-30 708
由于数组的一些局限性，在事先必须提前定义大小，然而现实生活中，很多数据元素的大小都不能事先知道，所以数组就不能很好的处理这些事情，然而链表可以弥补数组带来的诸多不便，链表可以让我们任意为一些数据进行空间开辟，根据需要进行内存单元的动态开辟...
数据结构：链表实现增删查改的基本功能【内含详细代码，建议收藏】
weixin_53472920的博客
09-15 3541
hello，大家好，这期文章继续用来更新数据结构方面的知识——链表。。这期文章依旧是对之前的文章[数据结构：红玫瑰与白玫瑰之争](https://blog.csdn.net/weixin_53472920/article/details/115463675)的补充，希望对大家有所帮助。我们在之前的文章中已经介绍过顺序表，链表和顺序表有很大的不同，相对于顺序表，链表无疑是更加灵活的。顺序表在实现过程中头部插入数据时需要挪动数据，在增容的过程中也会消耗性能，并且以倍数的方式增容也会造成空间的浪费。链表 ...
链表实现增删查改
zhengyawen666的博客
04-26 1212
一 链表的特点 1 按需申请空间 由于每一块物理空间都是单独申请的，因此需要考虑如何关联每一个内存块 -》用指针关联（每个节点存放两个东西：内容和指向下一个内存块的指针） 相比于顺序表空间浪费较小：一次开辟两倍，过多浪费；频繁开辟那么频繁访问内存，效率低下。 2 效率更高 头部或者中间插入删除，不需要挪动数据（顺序表需要），相对于顺序表效率更高，因为顺序表再头部或者中间插入的话，需要挪动数据。 总结：链表与顺序表优势互补，各有特点。 二 链表的结构 对于单向不循环链表 每个节点包括所
C++实现单链表的增删改查操作解析
在本文中，我们将深入探讨如何在C++中实现单链表的增、删、改、查等基本操作。 首先，我们来看一下单链表的定义。在提供的代码示例中，定义了一个名为`Student`的结构体，它包含两个字符串成员`name`和`score`，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值