自己编写链表函数库详解

最新推荐文章于 2024-01-20 12:43:32 发布
原创 最新推荐文章于 2024-01-20 12:43:32 发布 · 1k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#d #da

本文详细探讨了如何从零开始编写自己的链表函数库，涵盖了头文件的创建，以及一系列关键的链表操作函数实现，包括插入、删除、遍历等核心功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

头文件

#ifndef _LINKLIST_H
#define _LINKLIST_H

#define SUCCESS 10000
#define FAILURE 10001
#define TRUE    10002
#define FALSE   10003

typedef int ElemType;

struct node
{
    ElemType data;      //数据域
    struct node *next;  //指针域
};

typedef struct node Node;

int InitLinkList(Node **l);
int InsertLinkList(Node *l, int n, ElemType e);
int TraverseLinkList(Node *l, void(*p)(ElemType));
int LinkList_Len(Node *l);
int LinkListEmpty(Node *l);
int GetElem(Node *l, int n, ElemType *e);
int LocateElem(Node *l, ElemType e, int (*p)(ElemType,ElemType));
int DeleteLinkList(Node *l, int p, ElemType *e);
int ClearLinkList(Node *l);      
int DestroyLinkList(Node **l);
int ReverseLinkList(Node *l);

#endif

函数库

#include "LinkList.h"
#include <stdlib.h>

//初始化条件：结构体指针已存在,并且传入函数
//参数：Node **l l是一个指针，l的类型是Node **,l指向的类型是Node *
//函数功能：创建一个首结点，该结点指针域为NULL
int InitLinkList(Node **l)
{
    (*l) = (Node *)malloc(sizeof(Node) * 1);
    if(NULL == *l)
    {
        return FAILURE;
    }

    (*l)->next = NULL;

    return SUCCESS;
}

//初始化条件；头指针传入函数，位置n不大于链表的长度
//参数：l 头指针 n 要插入的位置 e 要插入的数据
//函数功能：在链表中新插入一个结点
int InsertLinkList(Node *l, int n, ElemType e)
{
    Node *p = l;                //定义一个指针指向头结点
    int k = 1;                      //移动的次数

    if (NULL == l)              //入参判断
    {
        return FAILURE;
    }

    while (k < n && p != NULL)  //p移动到指向要插入位置前一个结点
    {
        p = p->next;
        k++;
    }

    if (k > n || NULL == p) //所有意外情况都包含进去了
    {
        return FAILURE;
    }

    Node *q = (Node *)malloc(sizeof(Node) * 1); //  给新节点分配空间
    if (NULL == q)          //检查是否分配成功
    {
        return FAILURE;
    }

    q->data = e;            //给新创建的结点赋值
    q->next = p->next;      //新结点指向原来n处的结点
    p->next = q;            //原来n的前一个结点指向新结点

    return SUCCESS;
}

//初始化条件，头指针传入函数
//参数：l 头指针 p 函数指针，指向输出函数
//函数功能：逐个输出链表每个结点的值
int TraverseLinkList(Node *l, void(*p)(ElemType))
{
    Node *q = l;                //定义一个指针指向头结点

    if (NULL == l)               //入参判断
    {
        return FAILURE;
    }

    while (q->next != NULL)     //当q指向最后一个结点的时候结束循环
    {
        q = q->next;            //q指向后一个结点
        p(q->data);             //输出q指向结点的数据
    }

    return SUCCESS;
}

//初始化条件：头指针传入函数
//参数：l头指针
//函数功能：求出链表的长度
int LinkList_Len(Node *l)
{
    if (NULL == l)
    {
        return FAILURE;
    }

    int len = 1;
    Node *p = l->next;

    while (p)
    {
        len++;
        p = p->next;
    }

    return len;
}

//初始化条件：
//参数 l 头指针
//函数功能，判断链表是否为空
int LinkListEmpty(Node *l)
{
    return (NULL == l->next) ? TRUE : FALSE; //头结点之后没有结点，为空链表
}

//初始化条件:头指针传入函数，结点n不小于1，结点n要存在
//参数: l 头指针 n 要查看的位置 e 保存查看的那个结点的数据
//函数功能：得到链表中第n个结点的数据并返回其值
int GetElem(Node *l, int n, ElemType *e)
{
    if (NULL == l || n < 1)
    {
        return FAILURE;
    }

    Node *p = l;
    int i;

    for (i = 0; i < n && p != NULL; i++)
    {
        p = p->next;
    }

    if (!p)
    {
        return FAILURE;
    }

    *e = p->data;
    
    return SUCCESS;
}

//初始化条件：头指针传入函数
//参数 l 头指针 e 要查找的元素 p 函数指针 指向比较函数
//函数功能：查看e在链表中的第几个结点
int LocateElem(Node *l, ElemType e, int (*p)(ElemType,ElemType))
{
    if (NULL == l)                  //入参判断
    {
        return FAILURE;
    }

    Node *q = l->next;              //定义一个结点指向第一个节点
    int len = 1;                    //结点的个数

    while (q)                       //挨个比较e与结点数据是否相等
    {   
        if (TRUE ==p(e,q->data))    //如果相等，返回第几个结点
        {
            return len;
        }
        q = q->next;                //指向下一个结点
        len++;                      //结点个数加1
    }

    return FAILURE;                 //如果没有，返回失败
}

/*
 *参数: l 头指针
 *      p 要删除的位置，不能大于链表长度，不能小于1 
 *      e要保存p处结点的数据
 *函数功能：删除p处结点，并保存其数据域的值
 *返回值：SUCCESS/FAILURE
 */
int DeleteLinkList(Node *l, int p, ElemType *e)
{
    if (NULL == l)              //入参判断
    {
        return FAILURE;
    }

    int k = 1;                  //移动次数
    Node *q = l;

    while (k < p && q != NULL)
    {
        q = q->next;
        k++;
    }
                                //找到要删除的位置前一个结点
    if (k > p || NULL == q)
    {
        return FAILURE;
    }

    Node *n = q->next;          //定义一个指针指向要删除的结点
    *e = n->data;               //保存要删除结点的数据
    q->next = n->next;      //将要删除的结点与要删除的结点后面一个结点建立联系
    free(n);                //释放给要删除结点分配的空间

    return SUCCESS;
}

/*
 *参数：l 头指针
 *实现功能：删除除了头结点外的所有结点
 *返回值：SUCCESS/FAILURE
 */
int ClearLinkList(Node *l)
{
    if (NULL == l)              //入参判断
    {
        return FAILURE; 
    }
    
    Node *p = l->next;          //指针p指向第一个结点
    while (p)                   //while循环删除第一个结点以后所有结点
    {
        l->next = p->next;      
        free(p);
        p = l->next;
    }

    return SUCCESS;
}


/*
 * 参数：l头指针 不为空
 * 实现功能：销毁链表，释放为链表分配的空间
 * 返回值：SUCCESS/FAILURE
 */
int DestroyLinkList(Node **l)
{
    if (NULL == l)          //入参判断
    {
        return FAILURE;
    }

    free(*l);               //释放链表空间
    *l = NULL;              //不变为空指针，会成野指针，内存泄漏

    return SUCCESS;
}

/*
 *参数：l 头指针 不为空
 *实现功能：反转链表
 *返回值：TRUE/FALSE
 */
int ReverseLinkList(Node *l)
{
    if (NULL == l)          //入参判断
    {
        return FAILURE;
    }

    Node *p = l->next;      //p指向第一个结点
    l->next = NULL;         //首结点与第一个结点断开

    while (p)               //执行循环直到最后一个结点
    {
        Node *q = p;        //指针q指向p
        p = p -> next;      //p指向下一个结点
        q->next = l->next;  //将q结点与头结点后面一个结点相连
        l->next = q;        //头结点与q相连
    }

    return SUCCESS;
}

 

13、双链表与链表算法详解
purple的博客
07-07 10
本文详细介绍了双链表的定义与实现，包括其在数据结构中的优势和应用场景。同时探讨了链表排序算法，如冒泡排序和归并排序的原理、实现及其性能特点。通过代码示例和测试用例验证了双链表操作和排序算法的正确性，并提出了优化建议以提高效率。文章还分析了双链表与数组在不同操作上的性能差异及适用场景，旨在帮助读者更好地掌握链表相关知识并应用于实际开发中。
linux内核链表库
12-12
linux内核链表插入，排序函数库，库里面包含了一些宏。可以进行链表的插入，，删减。与一般链表不同的是，可以连接不同类型的数据。
c语言通用链表库
02-02
本代码提供采用c语言编写链表的使用源码，有创建、初始化、删除、插入、查找等等功能
链表的各种函数
weixin_30838921的博客
06-17 146
# include <stdio.h> # include <stdlib.h> struct node { int data; struct node *next; } ; struct node *creat1(int n) //顺序建立链表 { struct node *head, *tail, *p; ...
LRU缓存机制
m0_49252661的博客
10-09 249
LRU缓存机制LeetCode146官方题解 struct DLinkedNode { int key, value; DLinkedNode* prev; DLinkedNode* next; DLinkedNode(): key(0), value(0), prev(nullptr), next(nullptr) {} DLinkedNode(int _key, int _value): key(_key), value(_value), prev(nullptr
链表
weixin_34384915的博客
10-16 115
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查...
链表的常用函数
KaiLoveM的博客
11-30 935
头文件：#ifndef _LINKLIST_H_ #define _LINKLIST_H_#define SUCCESS 1000001 #define FAILURE 1000002 #define TRUE 1000003 #define FALSE 1000004 typedef int ElemType;struct node { ElemType data; st
OPNET核心函数库详解及应用
OPNET的核心函数库设计灵活，允许用户使用C/C++语言编写自定义模块，这些模块可以直接与OPNET的内部机制交互，从而实现高度定制的仿真场景。通过深入理解和熟练运用这些核心函数，用户能够创建精确、详尽的网络模型...
C语言实现多态链表及其功能详解
4. 编写管理函数，使得对链表的操作依赖于节点的具体类型，实现多态。 #### 多态链表的应用场景 多态链表在处理具有共同行为但不同属性的数据集时特别有用。例如，如果需要对不同类型的对象（如人类、动物、电话等...
C#实现基础链表类MyLinkedList详解
尽管C#标准库提供了`System.Collections.Generic.LinkedList`类来方便开发者使用链表，但在某些情况下，我们可能需要自定义链表类以满足特定需求或进行教学目的。本文中，我们将探讨如何用C#实现一个简单的单链表类...
MFC中括号匹配与链表合并技术详解
这两个问题在MFC（Microsoft Foundation Classes）中可能会以不同的形式出现，MFC是微软提供的一套C++库，封装了Windows API，用于简化Windows平台下的应用程序开发。 具体到文件标题“括号匹配和链表合并mfc”，...
链表处理函数（自己总结）
weixin_34245749的博客
03-15 148
// LinkList.h: interface for the CLinkList class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_LINKLIST_H__DBA19BDD_A667_4BB6_8021_9EE13990ED41__I...
C语言 链表基本函数
weixin_33734785的博客
06-01 258
#include<stdio.h> #include<malloc.h> typedefstructmy_nodemynode; structmy_node{ structmy_node*next; intdata; }; voidpush_node(mynode**head,int...
数据结构基础函数库——链表
最新发布
m0_72955669的博客
01-20 417
【代码】数据结构基础函数库——链表。
链表的函数
kyriekk的博客
04-15 1310
如题所示，本文是围绕链表与函数展开的，也就是如何传进传出以及遇到的问题。 1-- 首先观察如下代码，这是之前的知识（套中套那部分），指针p指向一个int变量k，指针pp指向p， 注意他们都是一级指针，所以这里的指针pp紧紧是指向，他具有修改*p也就是k的值的能力，但是！他并没有改变p的地址的能力。 #include <stdio.h> int main() { int k=0; int* p=&k; int* pp=p; *pp=2; printf("%d",k);
链表常用函数实现
Luyaooooo0的博客
05-13 389
数据结构-线性结构-单向链表常规函数 #include<stdio.h> #include<stdlib.h> #include<stdbool.h> #define Elemtype int //所有列表均含头节点,单向链表 //节点定义 struct node{ Elemtype val; struct node* next; }; ...
链表常用函数总结
Det10528的博客
10-28 2859
//创建单链表 PNODE creat_list() { int len; int i; int val; PNODE pHead=NULL; pHead=(PNODE)malloc(sizeof(NODE)); if(NULL==pHead) { printf("分配内存失败，请重新输入"); } PNODE pTail=pHead; pTail->Next=NULL; printf("请您输入需要链表的的个数%d",len); scanf("%d",&.
数据结构之自建算法库——单链表
weixin_33887443的博客
09-11 191
　　本文针对数据结构基础系列网络课程(2)：线性表中第10课时单链表基本操作的实现，建立单链表数据存储结构基本操作的算法库。 　　按照“0207将算法变程序”[视频]部分建议的方法，建设自己的专业基础设施算法库。 　　单链表算法库算法库采用程序的多文件组织形式，包括两个文件： 　　 　　1.头文件：linklist.h，包含定义...
链表的各种操作函数总结
ArtinCode
01-27 469
逆序生成函数 适用于生成n个节点的逆序链表。 node* reverse_add(int n) { node *p,*head; head=new node; head->next=NULL; while(n--){ p=new node; cin>>p->data; p->next=head->next
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值