C语言实现单链表的基本操作

最新推荐文章于 2022-10-22 19:23:57 发布
最新推荐文章于 2022-10-22 19:23:57 发布
阅读量353 收藏 1
点赞数
文章标签： c语言 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaoruxue918/article/details/70326885
版权

ListNode.h

#ifndef __LISTNODE_H__
#define __LISTNODE_H__

#include "stdio.h"
#include "assert.h"
#include "stdlib.h"

typedef int DataType;
typedef unsigned int size_t;

typedef struct Node
{
    DataType _data;
    struct Node* _pNext;
}Node,*PNode;

// 初始化单链表
void InitList(PNode* pHead);
//尾插
void PushBack(PNode* pHead, DataType data);
// 尾删
void PopBack(PNode* pHead);
// 头插
void PushFront(PNode* pHead, DataType data);
// 头删
void PopFront(PNode* pHead);
// 在单链表中查找值为data的结点，找到了返回该结点的地址，否则返回NULL
Node* Find(PNode pHead, DataType data);
// 在单链表pos位置后插入值为data的结点
void Insert(PNode pos, DataType data);
// 在单链表中删除位置为pos的结点
void Erase(PNode* pHead, PNode pos);
// 移除单链表中第一个值为data的结点
void Remove(PNode* pHead, DataType data);
// 移除单链表中所有值为data的结点
void RemoveAll(PNode* pHead, DataType data)
// 获取单链表总结点的总个数
size_t Size(PNode pHead);
// 判断结点是否为空
int Empty(PNode pHead);
// 返回单链表的最后一个结点的位置
PNode Back(PNode pHead);
// 返回单链表的第一个结点的位置
PNode Front(PNode pHead);
// 构建一个新节点
Node* BuyNode(DataType data);
// 正向打印单链表
void PrintList(PNode pHead);
//销毁链表  
void DestroyList(PNode *pHead);

#endif

ListNode.c

#include "ListNode.h"

// 初始化单链表
void InitList(PNode* pHead)
{
    assert(pHead);
    *pHead = NULL;
}

//尾插
void PushBack(PNode* pHead, DataType data)
{
    assert(pHead);
    if(*pHead == NULL)
        *pHead = BuyNode(data);
    else
    {
        Node* pTailNode = *pHead;
        while(pTailNode->_pNext)
            pTailNode = pTailNode->_pNext ;
        pTailNode->_pNext = BuyNode(data);
    }
}

// 尾删
void PopBack(PNode* pHead)
{
    assert(pHead);
    if(NULL == *pHead)
        return ;
    else if(NULL == (*pHead)->_pNext)
    {
        free(*pHead);
        (*pHead)->_pNext = NULL;
    }
    else
    {
        Node *pNode = *pHead;
        while(pNode->_pNext->_pNext)
        {
            pNode = pNode->_pNext ;
        }
        free(pNode->_pNext );
        pNode->_pNext = NULL;
    }
}

// 头插
void PushFront(PNode* pHead, DataType data)
{
    Node *pNew = NULL;
    assert(pHead);
    pNew = BuyNode(data);
    pNew->_pNext = *pHead;
    *pHead = pNew;

}

// 头删
void PopFront(PNode* pHead)
{
    assert(pHead);
    if(NULL == pHead)
        return ;
    else if(NULL == (*pHead)->_pNext)
    {
        free(*pHead);
        (*pHead)->_pNext = NULL;
    }
    else
    {
        Node *pNew = *pHead;
        *pHead = (*pHead)->_pNext ;
        free(pNew);
    }

}

// 在单链表中查找值为data的结点，找到了返回该结点的地址，否则返回NULL
Node* Find(PNode pHead, DataType data)
{
    Node *pCurNode = NULL;
    assert(pHead);
    if(NULL == pHead)
        return NULL;
    pCurNode = pHead;
    while((pCurNode != NULL)&&(pCurNode->_data != data))
        pCurNode = pCurNode->_pNext ;
    return pCurNode;
}

// 在单链表pos位置后插入值为data的结点
void Insert(PNode pos, DataType data)
{
    Node *pNewNode = NULL;
    assert(pos);

    if(!(pNewNode = BuyNode(data)))
        return ;
    pNewNode->_pNext = pos->_pNext ;
    pos->_pNext = pNewNode;
} 

// 在单链表中删除位置为pos的结点
void Erase(PNode* pHead,PNode pos)
{
    Node *pPreNode = NULL;
    assert(pHead);
    assert(pos);

    if(NULL == *pHead)//链表为空时
        return ;
    else if(pos == *pHead)//链表的第一个节点就为pos
        PopFront(pHead);
    else//pos不在头位置
    {
        pPreNode = *pHead;
        while(pPreNode && pPreNode->_pNext != pos)
            pPreNode = pPreNode->_pNext ;
        if(NULL != pPreNode)
        {
            pPreNode->_pNext = pos->_pNext ;
            free(pos);
            pos->_pNext = NULL;
        }
    }
}

// 移除单链表中第一个值为data的结点
void Remove(PNode* pHead, DataType data)
{
    Node *pDelNode = NULL;
    assert(pHead);
    if(NULL == *pHead)
        return ;
    else 
    {
        pDelNode = Find(*pHead,data);
        Erase(pHead,pDelNode);
    }
}

// 移除单链表中所有值为data的结点
void RemoveAll(PNode* pHead, DataType data)  
{  
    PNode pDelNode = NULL;  
    assert(NULL != pHead);  
    pDelNode = *pHead;  

    if (NULL == *pHead)     //链表为空  
        return ;  

    if (NULL == (*pHead)->_pNext) //链表只有一个节点  
    {  
        if ((*pHead)->_data == data)  
            PopFront(pHead);  
    }  
    else  
    {    
        while (pDelNode->_pNext )  
            if (pDelNode->_data == data)  
            {  
                PNode pTemp = pDelNode->_pNext;  

                pDelNode->_data = pTemp->_data;  
                pDelNode->_pNext = pTemp->_pNext;  

                free(pTemp);  
                pTemp = NULL;  
            }  
            else  
                pDelNode = pDelNode->_pNext;  
    }  
} 

// 返回单链表的第一个结点的位置
PNode Front(PNode pHead)
{
    assert(pHead);
    if(NULL == pHead)
        return NULL;
    else
    {
        Node *pFrontNode = pHead;
        return pFrontNode;
    }
}

// 返回单链表的最后一个结点的位置
PNode Back(PNode pHead)
{
    assert(pHead);
    if(NULL == pHead)
        return NULL;
    else
    {
        Node *pBackNode = pHead;
        while(pBackNode->_pNext )
            pBackNode = pBackNode->_pNext ;
        return pBackNode;
    }
}

// 获取单链表总结点的总个数
size_t Size(PNode pHead)
{
    unsigned int count = 0;
    assert(pHead);

    while(pHead)
    {
        pHead = pHead->_pNext ;
        count++;
    }
    return count;
}

// 判断结点是否为空
int Empty(PNode pHead)
{
    assert(pHead);
    if(NULL != pHead)
        return 0;//不为空
    return 1;//为空
}

// 正向打印单链表
void PrintList(PNode pHead)
{
    Node* pNode = pHead;
    assert(pHead);
    while(pNode)
    {
        printf("%d->",pNode->_data );
        pNode = pNode->_pNext ;
    }
    printf("\n");
}

// 构建一个新节点
Node* BuyNode(DataType data)
{
    Node *pNewNode = (Node*)malloc(sizeof(Node));

    if(pNewNode != NULL)
    {
        pNewNode->_data = data;
        pNewNode->_pNext = NULL;
    }
    return pNewNode;
}

//销毁链表  
void DestroyList(PNode *pHead)  
{  
    PNode pCurNode = NULL;  

    assert(pHead);  

    while (NULL != *pHead)  
    {  
        PNode pTemp = *pHead;  
        *pHead = (*pHead)->_pNext;  
        free(pTemp);  
        pTemp = NULL;  
    }  
}
雪沫沫
关注
单链表的基本操作实现（c语言）
yzy1123的博客
03-31 1351
#include <stdio.h> #include <string.h> #include <stdlib.h> //构造单链表 typedef struct LNode { int data;//数据域 struct LNode *next;//指针域 }LNode;//结构体名 //创建链表（带头结点） struct LNode* createList() { struct LNode* headNode = (struct LNode*)m.
单链表的基本操作（C语言实现）
sparkfeng
10-26 1214
最近在复习数据结构，想把数据结构里面涉及的都自己实现一下，完全是用C语言实现的。 自己编写的不是很好，大家可以参考，有错误希望帮忙指正，现在正处于编写阶段，一共将要实现19个功能。到目前我只写了一半，先传上来，大家有兴趣的可以帮忙指正，谢谢 在vs2010上面编译运行无错误。 #include "stdafx.h" #incl
C语言实现单链表基本操作
Yz529的博客
05-28 224
单链表基本的操作有增删改查： 基本操作代码如下： 初始化： typedef struct list_node { int data; struct list_node *next; } LinkList; //初始化单链表L为空--头结点,即创建头结点 LinkList *ListInit(LinkList *L) { L = (LinkList *)malloc(sizeof(LinkList)); if (!L) { exit(-1);
基于C语言实现单链表的基本操作
最新发布
03-25
以上就是使用C语言实现单链表的基本操作。通过这些函数，我们可以对链表进行各种常见的操作，例如创建、插入、删除、查找、打印、计算长度以及反转。在实际应用中，可以根据具体需求扩展这些功能，比如合并两个已...
用C语言实现单链表的各种操作(一)
09-05
本文将详细介绍如何用C语言实现单链表的各种操作。 首先，我们定义链表的结构体`LNode`，它包括一个数据域`ElemType data`和一个指向下一个节点的指针`struct LNode *next`： ```c typedef struct LNode{ ...
C语言--单链表的基本操作
yu1368072332的博客
09-26 504
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef struct Node { int value; struct Node *next; } lsNode; lsNode *InitLink(int count) { lsNode *head = (lsNode*)malloc(sizeof(lsNode)); /...
用C语言实现单链表的创建和基本操作
06-19
用C语言实现链表，并且对链表进行1、从表头到表尾以次输出链表元素。2、在单链表中第i个元素位置之前插入数据元素。3、删除链表上的第n个元素。4、查找链表中是否有某个元素。5、求链表的长度。6返回第i个位置的元素的值
c语言单链表的基本操作
weixin_64028674的博客
04-01 3608
该程序包含了链表的头插法、尾插法、求表长、按位查找、按值查找、插入、删除、销毁等几种操作； #include <stdio.h> #include <stdlib.h> //malloc和free都需要这个系统库函数头文件； typedef struct node//这里一定要有结构体变量名 { char data; struct node *next; }listnode; typedef listnode* linklist; linklist h
单链表的基本操作(C语言实现)
ygp12345的博客
08-27 668
头结点、头指针 带头结点和不带头结点 优势1：第1个位置的插入删除更加方便 优势2:统一空表和非空表的处理 若使用头结点，无论表是否为空，头指针都指向头结点，也就是*LNode类型，对于空表和非空表的操作是一致的。 若不使用头结点，当表非空时，头指针指向第1个结点的地址，即*LNode类型，但是对于空表，头指针指向的是NULL，此时空表和非空表的操作是不一致的。 创建一个单链表 //下面是尾插法建立 //声明节点结构 typedef struct Link{ int elem;//存储整形元素
【数据结构】C语言实现单链表基本操作
weixin_43716338的博客
02-05 3364
#include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int Status; typedef int ElemType; //单链表的存储结构 typedef struct LNode { ElemType data; struct LNode *next; //next指向自身类型struct LNode *的指
运用C语言实现单链表的基本操作（编写于2021.10.9）
mo_you_的博客
10-09 1363
C语言实现单链表 用C语言实现单链表的基本操作 1 、初始化单链表 2 、 销毁单链表 3 、 头插法建立单链表 4 、 尾插法建立单链表 5 、 输出单链表内容 6 、 按位置取值 7 、 插入数据元素 8 、删除数据元素 完整代码展示 #include<stdio.h> #include<stdlib.h> #define LIST_INIT_SIZE 10 #define LIST_INCREMENT 2 #define TRUE 1 #define FALSE 0 #d
C语言之实现单链表的基本操作
就是菜啊！
02-24 1792
目录 1、链表节点的定义 2、链表基操Function的声明 3、链表基操Function的定义与实现 3.1 单链表的创建（头插法） 3.2单链表的创建（尾插法） 咱们再来看看尾插法是怎么操作的呢？尾插法啊！就是将新节点插入到单链表的尾巴处，那么？我们如何得知哪里是单链表的尾巴处呢？这里我们放置一个“小兵”，这个小兵啥都不干，就是帮咱们记录“单链表的尾巴”在哪里，找到尾巴了，把新节点插入到尾巴后面，此时咱们的小兵指向的不在是单链表的尾巴了，我们需要让小兵往后挪一个节点（更新小兵的指向...
用C语言实现单链表的基本操作（附有完整代码）
m0_64365419的博客
10-22 7903
单链表的基本概念和定义以及实现过程。
实现单链表的基本操作（c语言）
qq_63152286的博客
02-18 5485
链表介绍 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 一、实现单链表的具体操作 定义链表元素 创建单链表：①头插法 ②尾插法 按位序插入结点 按位序删除结点 按位查找结点 销毁顺序表 打印链表
LeetCode-707-设计链表-C语言
SFFS
05-08 445
typedef struct ListNode Node; typedef struct { /* 一个虚拟的节点，node.next才是链表的头节点 */ Node node; /* 用于记录链表的尾节点 */ Node *rear; /* 用于记录链表的长度，根据长度判断，检索插入等操作是否合法 */ int len; } ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值