结构体的链表操作，创建增加删除查询

最新推荐文章于 2022-12-11 15:05:37 发布
最新推荐文章于 2022-12-11 15:05:37 发布
阅读量319 收藏
点赞数
文章标签： 链表 数据结构 单链表 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whnyao1314/article/details/105562184
版权

 

/***************************** Include Files *********************************/
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "sp_list.h"

/************************** Constant Definitions *****************************/

/**************************** Type Definitions *******************************/
typedef struct tag_STRU_SP_LIST_ELEMENT
{
    void *pvUserElement;
    struct tag_STRU_SP_LIST_ELEMENT *pstruNext;
}STRU_SP_LIST_ELEMENT;

typedef struct tag_STRU_SP_LIST
{
    u32 u32ElementSize;
    u32 u32ElementNum;
    PFUNC_CONSTRUCTOR pFuncConstructor;
    PFUNC_DESTRUCTOR pFuncDestructor;
    STRU_SP_LIST_ELEMENT *pstruListHead;
    STRU_SP_LIST_ELEMENT *pstruListTail;
}STRU_SP_LIST;


/***************** Macros (Inline Functions) Definitions *********************/

/************************** Function Prototypes ******************************/
extern STRU_SP_LIST_ELEMENT * SP_LIST_CreateNewElement(PLIST pList, void *pvUserElement);
extern void SP_LIST_DestroyElement(PLIST pList, STRU_SP_LIST_ELEMENT * pstruListElement);
extern STRU_SP_LIST_ELEMENT * SP_LIST_GetListElementAt(PLIST pList, u32 u32Pos);
/************************** Variable Definitions *****************************/

/************************** Function Definitions *****************************/
PLIST SP_LIST_Create(u32 u32ElementSize, PFUNC_CONSTRUCTOR pFuncConstructor, PFUNC_DESTRUCTOR pFuncDestructor)
{
    PLIST pNewList = (PLIST)malloc(sizeof(STRU_SP_LIST));
    if(C_SYS_NULL != pNewList)
    {
        pNewList->u32ElementSize = u32ElementSize;
        pNewList->u32ElementNum = 0;
        pNewList->pstruListHead = C_SYS_NULL;
        pNewList->pstruListTail = C_SYS_NULL;
        if (C_SYS_NULL == pFuncConstructor)
        {
            pNewList->pFuncConstructor = SP_LIB_DefaultConstructor;
        }
        else
        {
            pNewList->pFuncConstructor = pFuncConstructor;
        }

        if (C_SYS_NULL == pFuncDestructor)
        {
            pNewList->pFuncDestructor = SP_LIB_DefaultDestructor;
        }
        else
        {
            pNewList->pFuncDestructor = pFuncDestructor;
        }

    }
    return pNewList;
}


void SP_LIST_Destroy(PLIST pList)
{
    if(C_SYS_NULL != pList)
    {
        while (!SP_LIST_IsEmpty(pList))
        {
            SP_LIST_Remove(pList, 0);
        }
        free(pList);
    }
}
u32 SP_LIST_Append(PLIST pList, void *pvNewElement)
{
    STRU_SP_LIST_ELEMENT *pstruNewListElement = C_SYS_NULL;
    u32 u32NewElementPos = 0;

    if ((C_SYS_NULL == pList) || (C_SYS_NULL == pvNewElement))
    {
        return C_SP_LIB_INVALID_POSITION;
    }

    pstruNewListElement = SP_LIST_CreateNewElement(pList, pvNewElement);

    if (C_SYS_NULL != pstruNewListElement)
    {
        if(SP_LIST_IsEmpty(pList))
        {
            pList->pstruListHead = pstruNewListElement;
            pList->pstruListTail = pstruNewListElement;
        }
        else
        {
            pList->pstruListTail->pstruNext = pstruNewListElement;
            pList->pstruListTail = pstruNewListElement;
        }
        u32NewElementPos = pList->u32ElementNum;
        pList->u32ElementNum++;
        return u32NewElementPos;
    }
    else
    {
        return C_SP_LIB_INVALID_POSITION;
    }
}


STRU_SP_LIST_ELEMENT * SP_LIST_CreateNewElement(PLIST pList, void *pvUserElement)
{
    STRU_SP_LIST_ELEMENT *pstruNewListElement = C_SYS_NULL;

    if ((C_SYS_NULL == pList) || (C_SYS_NULL == pvUserElement))
    {
        return C_SYS_NULL;
    }

    pstruNewListElement = (STRU_SP_LIST_ELEMENT *)malloc(sizeof(STRU_SP_LIST_ELEMENT));

    if(C_SYS_NULL != pstruNewListElement)
    {
        pstruNewListElement->pstruNext = C_SYS_NULL;
        pstruNewListElement->pvUserElement = (*pList->pFuncConstructor)(pvUserElement, pList->u32ElementSize);
    }

    return pstruNewListElement;
}


u32 SP_LIST_Size(PLIST pList)
{
    if (C_SYS_NULL != pList)
    {        
        return pList->u32ElementNum;
    }
    else
    {
        return C_SP_LIB_INVALID_POSITION;
    }
}

SYS_BOOL SP_LIST_IsEmpty(PLIST pList)
{
    if (C_SYS_NULL != pList)
    {
        if (0 == pList->u32ElementNum)
        {
            return TRUE;
        }
        else
        {
            return FALSE;
        }
    }
    else
    {
        return TRUE;
    }
}


SYS_BOOL SP_LIST_Remove(PLIST pList, u32 u32Pos)
{
    STRU_SP_LIST_ELEMENT *pstruListElement = C_SYS_NULL;
    STRU_SP_LIST_ELEMENT *pstruFrontElement = C_SYS_NULL;
    STRU_SP_LIST_ELEMENT *pstruNextElement = C_SYS_NULL;

    if (C_SYS_NULL == pList)
    {
        return FALSE;
    }
    if (0 == pList->u32ElementNum)
    {
        return FALSE;
    }
    if (u32Pos >= pList->u32ElementNum)
    {
        return FALSE;
    }
    if (1 != pList->u32ElementNum)
    {
        pstruListElement = SP_LIST_GetListElementAt(pList, u32Pos);

        if (0 == u32Pos)
        {
            pstruNextElement = SP_LIST_GetListElementAt(pList, u32Pos + 1);
            SP_LIST_DestroyElement(pList, pList->pstruListHead);
            pList->pstruListHead = pstruNextElement;
 
        }
        else if (u32Pos == (pList->u32ElementNum - 1))
        {
            pstruFrontElement = SP_LIST_GetListElementAt(pList, u32Pos - 1);
            SP_LIST_DestroyElement(pList, pList->pstruListTail);
            pstruFrontElement->pstruNext = C_SYS_NULL;
            pList->pstruListTail = pstruFrontElement;
        }
        else
        {
            pstruFrontElement = SP_LIST_GetListElementAt(pList, u32Pos - 1);
            pstruNextElement = SP_LIST_GetListElementAt(pList, u32Pos + 1);

            SP_LIST_DestroyElement(pList, pstruListElement);
            pstruFrontElement->pstruNext = pstruNextElement;

        }
        pList->u32ElementNum --;

    }
    else
    {
        /*只有一个元素，就把链表头和尾都清空*/
        SP_LIST_DestroyElement(pList, pList->pstruListHead);
        pList->pstruListHead = C_SYS_NULL;
        pList->pstruListTail = C_SYS_NULL;
        pList->u32ElementNum = 0;
    }
    

    return TRUE;
}


void * SP_LIST_GetAt(PLIST pList, u32 u32Pos)
{
    STRU_SP_LIST_ELEMENT *pstruListElement = C_SYS_NULL;
   
    if (C_SYS_NULL == pList)
    {
        return C_SYS_NULL;
    }
    if (u32Pos >= pList->u32ElementNum)
    {
        return C_SYS_NULL;
    }

    pstruListElement = SP_LIST_GetListElementAt(pList, u32Pos);

    if (C_SYS_NULL != pstruListElement)
    {
        return pstruListElement->pvUserElement;
    }
    else
    {
        return C_SYS_NULL;
    }
}


STRU_SP_LIST_ELEMENT * SP_LIST_GetListElementAt(PLIST pList, u32 u32Pos)
{
    STRU_SP_LIST_ELEMENT *pstruListElement = C_SYS_NULL;
    u32 u32Count = 0;
    if (C_SYS_NULL == pList)
    {
        return C_SYS_NULL;
    }
    if (u32Pos >= pList->u32ElementNum)
    {
        return C_SYS_NULL;
    }
    
    pstruListElement = pList->pstruListHead;

    while (u32Count < u32Pos)
    {
        pstruListElement = pstruListElement->pstruNext;
        u32Count++;
    }

    return pstruListElement;

}



void SP_LIST_DestroyElement(PLIST pList, STRU_SP_LIST_ELEMENT * pstruListElement)
{
    if ((C_SYS_NULL == pList) || (C_SYS_NULL == pstruListElement))
    {
        return;
    }

    (*pList->pFuncDestructor)(pstruListElement->pvUserElement);
    pstruListElement->pvUserElement = C_SYS_NULL;
    free(pstruListElement);
}


u32 SP_LIST_Find(PLIST pList, PFUNC_COMPARE pFuncCompare, const void *pcvElementOutsight)
{
    STRU_SP_LIST_ELEMENT *pstruListElement = C_SYS_NULL;
    u32 u32Postion = 0;
    if((C_SYS_NULL == pList) 
        || (C_SYS_NULL == pFuncCompare)
        || (C_SYS_NULL == pcvElementOutsight))
    {
        return C_SP_LIB_INVALID_POSITION;
    }

    pstruListElement = pList->pstruListHead;
    while(C_SYS_NULL != pstruListElement)
    {
        if(0 == (*pFuncCompare)(pcvElementOutsight, pstruListElement->pvUserElement, pList->u32ElementSize))
        {
            return u32Postion;
        }
        u32Postion++;
        pstruListElement = pstruListElement->pstruNext;
    }
    return C_SP_LIB_INVALID_POSITION;
}


SYS_BOOL SP_LIST_Insert(PLIST pList, u32 u32Pos, void *pvElement)
{
    STRU_SP_LIST_ELEMENT *pstruNewListElement = C_SYS_NULL;
    STRU_SP_LIST_ELEMENT *pstruFrontElement = C_SYS_NULL;
    STRU_SP_LIST_ELEMENT *pstruListElement = C_SYS_NULL;

    if (C_SYS_NULL == pList)
    {
        return FALSE;
    }
    if (u32Pos >= pList->u32ElementNum)
    {
        return FALSE;
    }

    if (0 == u32Pos)
    {
        pstruNewListElement = SP_LIST_CreateNewElement(pList, pvElement);
        if (C_SYS_NULL != pstruNewListElement)
        {
            pstruNewListElement->pstruNext = pList->pstruListHead;
            pList->pstruListHead = pstruNewListElement;
            pList->u32ElementNum++;
            return TRUE;
        }
        else
        {
            return FALSE;
        }
    }
    else
    {
        pstruFrontElement = SP_LIST_GetListElementAt(pList, u32Pos-1);
        pstruListElement = SP_LIST_GetListElementAt(pList, u32Pos);
        pstruNewListElement = SP_LIST_CreateNewElement(pList, pvElement);

        if ((C_SYS_NULL != pstruNewListElement)
            && (C_SYS_NULL != pstruFrontElement)
            && (C_SYS_NULL != pstruListElement))
        {
            pstruFrontElement->pstruNext = pstruNewListElement;
            pstruNewListElement->pstruNext = pstruListElement;
            pList->u32ElementNum++;
            return TRUE;
        }
        else
        {
            return FALSE;
        }
    }
}


void SP_LIST_Traversal(PLIST pList, PFUNC_TRAVERSAL pFuncTraversal, void *pvParam)
{
    STRU_SP_LIST_ELEMENT *pstruListElement = C_SYS_NULL;
    if (C_SYS_NULL != pList)
    {
        pstruListElement = pList->pstruListHead;
        while(C_SYS_NULL != pstruListElement)
        {
            (*pFuncTraversal)(pstruListElement->pvUserElement, pvParam);
            pstruListElement = pstruListElement->pstruNext;
        }
    }

}

void * SP_LIST_GetNext(PLIST pList, u32 u32Pos)
{
    return SP_LIST_GetAt(pList, u32Pos + 1);
}

 

whnyao1314
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
结构体排序查找以及链表的使用
06-29
学习结构体排序查找以及链表的使用#include<stdio.h> #include<stdlib.h> #include<string.h> struct student { int num; double score; char name[100]; struct student *next; }; int cmp(const void *a,const void *b) { struct student *p1=(struct student*)a; struct student *p2=(struct student*)b; if(p1->score!=p2->score) return p1->score-p2->score?1:-1; else if(p1->num!=p2->num) return p1->num-p2->num; else return strcmp(p1->name,p2->name); } void main() { struct student s[100],*q,key,*p,*head; int n,i; while(scanf("%d",&n)!=EOF) { for(i=0;i<n;i++) scanf("%d %lf %s",&s[i].num,&s[i].score,s[i].name); head=&s[0]; for(i=1;i<n;i++) s[i-1].next=&s[i]; s[n-1].next=NULL; p=head; while(p) { printf("%d %.2lf %s\n",p->num,p->score,p->name); p=p->next; } qsort(s,n,sizeof(s[0]),cmp); head=&s[0]; for(i=1;i<n;i++) s[i-1].next=&s[i]; s[n-1].next=NULL; p=head; while(p) { printf("%d %.2lf %s\n",p->num,p->score,p->name); p=p->next; } scanf("%d %lf %s",&key.num,&key.score,key.name); q=(struct student*)bsearch(&key,s,n,sizeof(s[0]),cmp); if(q) printf("%d %.2lf %s",q->num,q->score,q->name); else printf("No\n"); } }
c语言指针和结构体链表详解ppt课件.ppt
11-20
结构体链表是一种重要的动态数据结构，具有动态性和灵活性，能够根据需要增加或减少元素个数，并且元素的位置可以变化。链表中的每个元素称为“结点”，每个结点包括两个域：数据域和指针域。 链表的基本操作包括...
数据结构 链表的删除
m0_64335500的博客
02-10 445
一：创建链表 #pragma once #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <malloc.h> //节点结构体 struct LinkNode { //数据源 int num; //指针域 struct LinkNode* next; }; //初始化链表 //创建函数返回值 创建链表的头节点 struct LinkNode* init
数据结构中链表的创建、添加、删除、清空、倒序输出及链表倒置
weixin_30629977的博客
03-18 147
1.创建链表 （1）申请空间，向申请的结点里存值 （2）看链表头是否为空，头为空，头添加，此时该节点即是头也是尾 （3）如果头不为空，尾的下一个添加，新的节点就是尾 代码实现： void CreateList(MyList** pTop,MyList** pEnd){ //因为创建链表，从无到有的过程，一般选择二级指针 int nNum; MyList* pTemp=NULL; ...
零基础入门学习C语言011讲：结构体与共用体（5）链表的删除与插入
来自江南的你的博客
05-02 357
对链表的删除操作 从一个动态链表中删去一个结点，并不是真正从内存中把它抹掉，而是把它从链表中分离开来，只要撤销原来的链接关系即可。 随堂练习 题目：写一函数以删除动态链表中指定的结点。 解题思路: 一、从p指向的第一个结点开始，检查该结点中的num值是否等于输入的要求删除的那个学号。 二、如果相等就将该结点删除，如不相等，就将p后移一个结点，再如此进行下去，直到遇到表尾为止。 三...
数据结构：1_链表_链表删除
Mmagic1的博客
12-20 256
代码复现list->delete()函数： #include <iostream> #include <list> /***********************************/ /* 1、如果插入位置不合理，抛出异常 /* 2、从最后一个元素开始向前遍历到第i个位置，分别将它们都向前移动一个位置 /* 3、将要插入的元素填入位置i处 * ...
C语言实现带头结点的链表的创建、查找、插入、删除操作
09-04
这种设计方便了链表的操作，尤其是对链表的创建、查找、插入和删除。 1. **链表的创建**： 在C语言中，创建链表首先需要定义一个结构体来表示链表节点，包含数据域`data`和指向下一个节点的指针`next`。创建带头...
C语言 XX管理系统 不用结构体 链表
04-13
链表的优势在于插入和删除操作通常比数组更快，因为它只需要改变相邻节点的指针，而不需要移动大量的内存。在管理系统中，链表常用于存储具有动态大小或顺序无关的元素。 既然该管理系统没有使用结构体和链表，那么...
单向链表(一) 结构体、创建链表、遍历链表
07-31
同时，链表的操作如删除节点、查找节点、反转链表等也是面试和编程竞赛中常见的问题。理解和熟练掌握链表的这些基本操作对于提升编程技能至关重要。 总结来说，单向链表是一种灵活的数据结构，其节点通过指针相互...
LianBiao.rar_lianbiao_结构体_链表 插入
09-22
在本示例中，我们关注的是“LianBiao.rar_lianbiao_结构体_链表 插入”，这表明我们将讨论如何实现一个链表类，该类能够处理特定结构体，并支持插入操作。让我们深入探讨链表的基本概念，结构体的使用，以及如何在...
C语言：结构体中链表的添加与删除
m0_69414302的博客
07-11 669
按值添加删除
结束结构体与简单链表
唐某人
12-06 330
1620-7  唐大智《2016年12月6日》[连续第六十六天总结] 标题：结束结构体与简单链表 关键词：总结注意点 内容（A） （1）在定义结构体类型时，成员不能初始化，也不能指定除了static以外的存储类型。 （2）结构体类型可以含自身类型的指针成员，但不能含自身类型的普通成员。 （3）类型定义：类型定义的本质是对一个已存在的类型重新命名，并不是定义新的数据类型。也不能定义变量。
【数据结构】单链表的删除
最新发布
zx1041561837的博客
12-11 1053
单链表的删除
结构体链表赋值与删除
徐奕的专栏
01-22 2290
#include<stdio.h> #include<malloc.h> #define LEN sizeof(struct student) struct student { char num[6]; char name[8]; char sex[2]; int age; struct student *next; }stu[10]; void main()
c++ 实现结构体单链表的 创建 插入 删除等操作
热门推荐
u012746763的专栏
06-12 1万+
#include using namespace std; enum operation{create_List=1,print_List,insert_Node,delete_Node,delete_List,quit};//枚举类型，用于菜单选择结果 struct node //结点结构 { int data ; node * next; }; operation
数据结构之链表的删除
StevenBian的博客
05-06 7474
思路分析 1：因为题目中只给定了要删除的节点,并没有给出链表的头结点，所以无法通过遍历查询到待删除节点的上一个节点，然后执行删除操作 2：对此，我们利用给定的待删除节点的信息，将待删除节点的下一个节点的值付给待删除的节点，这样就可以将待删除节点的next指针域指向下一个节点的下一个，从而实现删除操作 class Solution { public void deleteNode(ListNode node) {
golang基础-结构体、结构体链表前后插入、节点添加删除
全干工程师
10-26 7774
结构体 struct 用来自定义复杂数据结构 struct里面可以包含多个字段（属性） struct类型可以定义方法，注意和函数的区分 struct类型是值类型 struct类型可以嵌套 Go语言没有class类型，只有struct类型
链表结构以及链表的操作（结构体实现）
weixin_47089544的博客
06-10 1134
结构的嵌套 #include <iostream> #include <cstring> using namespace std; struct Education { char major[30]; char degree[20]; double GPA; }; struct Student { Education school;//结构中嵌套一个Education结构 char id[20]; int grade; }; int
单向链表的建立，删除，插入操作
看花容易绣花难
04-29 1687
#include<stdio.h> #include<stdlib.h> struct link *appendnode(struct link *head); void displaynode(struct link *head); void deletememory(struct link *head); struct link { int data; stru...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值