数据结构单链表附完整代码----单链表的基本操作

已于 2024-05-07 10:40:29 修改
阅读量104 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 链表 算法 c++ c语言
于 2023-08-22 09:35:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75867204/article/details/132421073
版权

直接干货：

 

LinkList.h文件：

#pragma once

typedef int ElemType;

typedef struct LNode
{
    ElemType data;
    struct LNode* next;
}LNode, *LinkList;

void InitLinkList(LinkList* list);

LNode* _buyNode(ElemType Item);

void push_front(LinkList* list, ElemType x);

void push_back(LinkList* list, ElemType x);

void showList(LinkList* list);

void pop_back(LinkList* list);

void pop_front(LinkList* list);

int length_list(LinkList* list);

void insertLinklist_pos(LinkList* list, int pos, ElemType key);

void delete_LinkList_val(LinkList* list, ElemType x);

void sortLinkList(LinkList* list);

void reverseLinkList(LinkList* list);

int findval_val(LinkList* list, ElemType key);

int countX(LinkList* list, ElemType x);

void clearLinkList(LinkList* list);

void destroyLinkList(LinkList* list);

 

 


LinkList.c文件：

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

void InitLinkList(LinkList* list)
{
    *list = NULL;
}

LNode* _buyNode(ElemType Item)
{
    LNode* NewNode = (LNode*)malloc(sizeof(LNode));
    if (NewNode == NULL)
    {
        printf("Memory allocation failed.\n");
        exit(1);
    }
    NewNode->data = Item;
    NewNode->next = NULL;
    return NewNode;
}

void push_front(LinkList* list, ElemType x)
{
    LNode* NewNode = _buyNode(x);
    NewNode->next = *list;
    *list = NewNode;
}

void push_back(LinkList* list, ElemType x)
{
    if (*list == NULL)
    {
        push_front(list, x);
        return;
    }

    LNode* p = *list;
    while (p->next != NULL)
    {
        p = p->next;
    }

    LNode* NewNode = _buyNode(x);
    p->next = NewNode;
}

void showList(LinkList* list)
{
    if (*list == NULL)
    {
        printf("The LinkList is empty.\n");
        return;
    }

    LNode* p = *list;
    while (p != NULL)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

void pop_back(LinkList* list)
{
    if (*list == NULL)
    {
        return;
    }

    if ((*list)->next == NULL)
    {
        free(*list);
        *list = NULL;
        return;
    }

    LNode* p = *list;
    while (p->next->next != NULL)
    {
        p = p->next;
    }

    free(p->next);
    p->next = NULL;
}

void pop_front(LinkList* list)
{
    if (*list == NULL)
    {
        return;
    }

    LNode* p = *list;
    *list = (*list)->next;
    free(p);
}

int length_list(LinkList* list)
{
    int count = 0;
    LNode* p = *list;
    while (p != NULL)
    {
        count++;
        p = p->next;
    }
    return count;
}

void insertLinklist_pos(LinkList* list, int pos, ElemType key)
{
    if (pos < 0 || pos > length_list(list))
    {
        return;
    }

    if (pos == 0)
    {
        push_front(list, key);
        return;
    }

    LNode* p = *list;
    for (int i = 0; i < pos - 1; i++)
    {
        p = p->next;
    }

    LNode* NewNode = _buyNode(key);
    NewNode->next = p->next;
    p->next = NewNode;
}

void delete_LinkList_val(LinkList* list, ElemType x)
{
    if (*list == NULL)
    {
        return;
    }

    if ((*list)->data == x)
    {
        pop_front(list);
        return;
    }

    LNode* p = *list;
    while (p->next != NULL && p->next->data != x)
    {
        p = p->next;
    }

    if (p->next != NULL)
    {
        LNode* q = p->next;
        p->next = q->next;
        free(q);
    }
}

void sortLinkList(LinkList* list)
{
    if (*list == NULL || (*list)->next == NULL)
    {
        return;
    }

    LNode* p = *list;
    LNode* q;
    ElemType temp;

    while (p != NULL)
    {
        q = p->next;
        while (q != NULL)
        {
            if (p->data > q->data)
            {
                temp = p->data;
                p->data = q->data;
                q->data = temp;
            }
            q = q->next;
        }
        p = p->next;
    }
}

void reverseLinkList(LinkList* list)
{
    if (*list == NULL || (*list)->next == NULL)
    {
        return;
    }

    LNode* prev = NULL;
    LNode* current = *list;
    LNode* next;

    while (current != NULL)
    {
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }

    *list = prev;
}

int findval_val(LinkList* list, ElemType key)
{
    int index = 0;
    LNode* p = *list;
    while (p != NULL && p->data != key)
    {
        p = p->next;
        index++;
    }

    if (p == NULL)
    {
        return -1;
    }

    return index;
}

int countX(LinkList* list, ElemType x)
{
    int count = 0;
    LNode* p = *list;
    while (p != NULL)
    {
        if (p->data == x)
        {
            count++;
        }
        p = p->next;
    }
    return count;
}

void clearLinkList(LinkList* list)
{
    LNode* p = *list;
    while (p != NULL)
    {
        LNode* temp = p;
        p = p->next;
        free(temp);
    }
    *list = NULL;
}

void destroyLinkList(LinkList* list)
{
    clearLinkList(list);
}
LinkList.h文件：

#pragma once

typedef int ElemType;

typedef struct LNode
{
    ElemType data;
    struct LNode* next;
}LNode, *LinkList;

void InitLinkList(LinkList* list); // 初始化链表

LNode* _buyNode(ElemType Item); // 创建新结点

void push_front(LinkList* list, ElemType x); // 头插法插入结点

void push_back(LinkList* list, ElemType x); // 尾插法插入结点

void showList(LinkList* list); // 输出链表元素

void pop_back(LinkList* list); // 删除尾部结点

void pop_front(LinkList* list); // 删除头部结点

int length_list(LinkList* list); // 返回链表长度

void insertLinklist_pos(LinkList* list, int pos, ElemType key); // 在指定位置插入结点

void delete_LinkList_val(LinkList* list, ElemType x); // 删除指定元素的结点

void sortLinkList(LinkList* list); // 对链表进行排序

void reverseLinkList(LinkList* list); // 反转链表

int findval_val(LinkList* list, ElemType key);// 查找指定元素的位置

int countX(LinkList* list, ElemType x); // 统计指定元素出现的次数

void clearLinkList(LinkList* list); // 清空链表

void destroyLinkList(LinkList* list); // 销毁链表

LinkList.c文件：

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

void InitLinkList(LinkList* list)
{
    *list = NULL;
}

LNode* _buyNode(ElemType Item)
{
    LNode* NewNode = (LNode*)malloc(sizeof(LNode));
    if (NewNode == NULL)
    {
        printf("Memory allocation failed.\n");
        exit(1);
    }
    NewNode->data = Item;
    NewNode->next = NULL;
    return NewNode;
}

void push_front(LinkList* list, ElemType x)
{
    LNode* NewNode = _buyNode(x);
    NewNode->next = *list;
    *list = NewNode;
}

void push_back(LinkList* list, ElemType x)
{
    if (*list == NULL)
    {
        push_front(list, x);
        return;
    }

    LNode* p = *list;
    while (p->next != NULL)
    {
        p = p->next;
    }

    LNode* NewNode = _buyNode(x);
    p->next = NewNode;
}

void showList(LinkList* list)
{
    if (*list == NULL)
    {
        printf("The LinkList is empty.\n");
        return;
    }

    LNode* p = *list;
    while (p != NULL)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

void pop_back(LinkList* list)
{
    if (*list == NULL)
    {
        return;
    }

    if ((*list)->next == NULL)
    {
        free(*list);
        *list = NULL;
        return;
    }

    LNode* p = *list;
    while (p->next->next != NULL)
    {
        p = p->next;
    }

    free(p->next);
    p->next = NULL;
}

void pop_front(LinkList* list)
{
    if (*list == NULL)
    {
        return;
    }

    LNode* p = *list;
    *list = (*list)->next;
    free(p);
}

int length_list(LinkList* list)
{
    int count = 0;
    LNode* p = *list;
    while (p != NULL)
    {
        count++;
        p = p->next;
    }
    return count;
}

void insertLinklist_pos(LinkList* list, int pos, ElemType key)
{
    if (pos < 0 || pos > length_list(list))
    {
        return;
    }

    if (pos == 0)
    {
        push_front(list, key);
        return;
    }

    LNode* p = *list;
    for (int i = 0; i < pos - 1; i++)
    {
        p = p->next;
    }

    LNode* NewNode = _buyNode(key);
    NewNode->next = p->next;
    p->next = NewNode;
}

void delete_LinkList_val(LinkList* list, ElemType x)
{
    if (*list == NULL)
    {
        return;
    }

    if ((*list)->data == x)
    {
        pop_front(list);
        return;
    }

    LNode* p = *list;
    while (p->next != NULL && p->next->data != x)
    {
        p = p->next;
    }

    if (p->next != NULL)
    {
        LNode* q = p->next;
        p->next = q->next;
        free(q);
    }
}

void sortLinkList(LinkList* list)
{
    if (*list == NULL || (*list)->next == NULL)
    {
        return;
    }

    LNode* p = *list;
    LNode* q;
    ElemType temp;

    while (p != NULL)
    {
        q = p->next;
        while (q != NULL)
        {
            if (p->data > q->data)
            {
                temp = p->data;
                p->data = q->data;
                q->data = temp;
            }
            q = q->next;
        }
        p = p->next;
    }
}

void reverseLinkList(LinkList* list)
{
    if (*list == NULL || (*list)->next == NULL)
    {
        return;
    }

    LNode* prev = NULL;
    LNode* current = *list;
    LNode* next;

    while (current != NULL)
    {
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }

    *list = prev;
}

int findval_val(LinkList* list, ElemType key)
{
    int index = 0;
    LNode* p = *list;
    while (p != NULL && p->data != key)
    {
        p = p->next;
        index++;
    }

    if (p == NULL)
    {
        return -1;
    }

    return index;
}

int countX(LinkList* list, ElemType x)
{
    int count = 0;
    LNode* p = *list;
    while (p != NULL)
    {
        if (p->data == x)
        {
            count++;
        }
        p = p->next;
    }
    return count;
}

void clearLinkList(LinkList* list)
{
    LNode* p = *list;
    while (p != NULL)
    {
        LNode* temp = p;
        p = p->next;
        free(temp);
    }
    *list = NULL;
}

void destroyLinkList(LinkList* list)
{
    clearLinkList(list);
}

 

 

善程序员文
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数据结构单链表最全的实现代码
12-04
数据结构入门级必看的单链表，内含单链表比较全的算法实现源代码。
完整且详细的单链表代码
domain.5忘初心
10-17 598
链表类代码： package com.umpay.common.util.code; import java.util.NoSuchElementException; /** * 单链表:是一种链式存取的数据结构，它用一组地址任意(内存可以不连续)的存储单元存放线性表中的数据元素。 * Created by admin on 2019/10/12. * * @see java.util...
数据结构单链表代码(c语言实现)
qq_44972915的博客
04-06 2575
数据结构单链表代码 #include "stdio.h" #include "stdlib.h" #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int ElemType; typedef int Status; typedef struct Node { // 数据域+指针域 ElemType d...
有关单链表的面试题分析及代码实现
TerryZjl的博客
03-02 421
1.删除无头单链表的非尾结点 2.逆置/翻转单链表 3.在无头单链表的一个非头结点前插入一个节点 4.查找链表中间节点 5.删除单链表的倒数第K个节点（k>1&&k<链表长度）时间复杂度为O(N); 6.逆序打印单链表
C++实现单链表【每一步详细深入讲解，代码清晰、简单、易懂】
weixin_55755506的博客
12-03 4535
例如：我们需要在伪头节点（不包含数据）和含有1的节点之间插入一个节点，发现，只需要改变dummy的指针和需要插入的指针即可。通过对插入和删除的讨论，我们了解到，插入调用find函数时，并不需要操作其返回值，所以，返回值具体是该元素的节点还是其前面的节点并没有影响；，而第一个节点的前一个节点是dummy，这也是为什么我们需要dummy这个伪头节点。，因此，删除操作时我们必须得到需要删除节点的前一个节点，因此。先将要添加的元素的指针指向dummy节点的后一个节点。将要添加节点的指针指向之前的下一个节点。
数据结构与算法实验（C++）：单链表实验-代码
最新发布
01-18
2）熟练掌握单链表的基本操作算法； 3）熟练掌握面向对象程序设计方法； 4）能灵活使用单链表解决具体的问题。 （2）实验内容： 1）在主函数中定义对象，并调用成员函数，验证单链表的基本操作； 2）定义单链表类...
循环单链表的约瑟夫问题-完整代码
10-04
试用单循环链表为存储结构， 写一个约瑟夫(Josephu) 问题的算法。约瑟夫问题是：有N个人围成一圈，由第i个人开始从1报数，数到m时，此人就出列。下一个人重新从1开始报数，再数到m时，又一个人出列，直到所有的人...
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
12-02
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc 知识点摘要： 1. 数据结构的基本概念：数据结构是计算机科学中的一种基本概念，指的是数据的组织和存储方式。 2. 线性表的概念：线性表是一种基本...
数据结构-单链表的学习及代码实现
09-03
包含单链表的增加、删除、修改，增加分为两种，直接增加到链表的最后和按照编号添加到固定的位置。以及对这些代码的全部实现。 为了自己学习记录，如果里面有不正确的，还请指正
数据结构---线性表之单链表（C语言）
03-28
数据结构---线性表之单链表，包括单链表的创建、插入、删除等，C语言编写
《数据结构实验教程》胡学刚 上机实验—实验一 单链表实验源代码
07-19
数据结构实验教程》胡学刚 上机实验源代码实验一
数据结构实验——链表
12-14
数据结构实验——链表 数据结构实验——链表
【数据结构】C语言实现单链表万字详解(附完整运行代码)
C/C++领域,数据结构,linux,MySQl学习者
11-11 297
使用C语言实现单链表程序的新手入门万字详解,包括每个函数的设计原理图示,设计思路,每步代码的注释以及程序完整实现代码.
数据结构实验:单链表(一)
AA_Jun的博客
08-11 303
线性表的链式存储结构及其基本操作。
【数据结构】单链表&&静态链表详解和代码实例
infinitor的博客
06-29 311
&#13; 喜欢的话可以扫码关注我们的公众号哦，更多精彩尽在微信公众号【程序猿声】 01 单链表(Singly Linked List ) 1.1 什么是单链表？ 单链表是一种链式存储的结构。它动态的为节点分配存储单元。当有节点插入时，系统动态的为结点分配空间。在结点删除时，应该及时释放相应的存储单元，以防止内存泄露。由于是链式存储，所以操作单链表时，必须知道头结点或者头...
数据结构—单链表的操作与实现—c++代码（含全部代码）
Initial_Mind的博客
01-21 6085
单链表的操作与实现
数据结构-链表（含全部实现代码）
qq_45967533的博客
03-12 7176
本篇的内容是对链表的一个介绍，并且会使用C语言实现链表的几个主要接口。 目录链表的概念与结构 链表的概念与结构 概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。 一个链表由n个节点组成，每一个节点都是一个结构体，这个结构体里的一个成员是该节点存储的数据，另一个成员是指向下一个节点的指针。 其结构如下 上图只是一种结构的链表，并不是所有的链表都是这样的结构，在实际中链表的结构非常多样，有以下几种情况：是否带头，单向还是双向，是否循环。共23=8种
单链表示例代码
xuyouqiang1987的博客
08-13 240
#include <iostream> #include <cassert> using namespace std; //定义单链表节点 class Node { public: Node() : data(0), next(nullptr) {}; int data; Node *next; }; /** * @brief 根据用户输入的数据创建单链表 * @param 无 * @return 单链表头节点的指针 */ Node *cre.
java单链表例子_单链表(示例代码)
weixin_33961375的博客
02-25 145
单链表实例：使用带head头的单向链表实现--水浒英雄排行榜管理插入链表节点的方法思路：注：头节点不能动，一旦动了，就无法在遍历了，遍历是从头节点开始的，所以需要一个辅助节点(可以当作指针指针)来进行遍历首先找到新添加的节点的位置,是通过辅助变量(指针),通过遍历找到新的节点.next =temp.next将temp.next=新的节点public void addByOrder(HeroNode...
数据结构单链表的基本操作代码C语言
04-04
1. 定义单链表结构体和节点结构体 ```c typedef struct ListNode { int data; struct ListNode *next; } ListNode; typedef struct LinkedList { ListNode *head; int length; } LinkedList; ``` 2. 创建一个空链表 ```c LinkedList *createLinkedList() { LinkedList *list = (LinkedList *)malloc(sizeof(LinkedList)); list->head = NULL; list->length = 0; return list; } ``` 3. 在链表尾部插入一个节点 ```c void insertAtTail(LinkedList *list, int data) { ListNode *newNode = (ListNode *)malloc(sizeof(ListNode)); newNode->data = data; newNode->next = NULL; if (list->head == NULL) { list->head = newNode; } else { ListNode *tail = list->head; while (tail->next != NULL) { tail = tail->next; } tail->next = newNode; } list->length++; } ``` 4. 在链表头部插入一个节点 ```c void insertAtHead(LinkedList *list, int data) { ListNode *newNode = (ListNode *)malloc(sizeof(ListNode)); newNode->data = data; newNode->next = list->head; list->head = newNode; list->length++; } ``` 5. 在链表中间插入一个节点 ```c void insertAtIndex(LinkedList *list, int index, int data) { if (index < 0 || index > list->length) { printf("Error: index out of range.\n"); return; } if (index == 0) { insertAtHead(list, data); return; } if (index == list->length) { insertAtTail(list, data); return; } ListNode *newNode = (ListNode *)malloc(sizeof(ListNode)); newNode->data = data; ListNode *prev = list->head; for (int i = 0; i < index - 1; i++) { prev = prev->next; } newNode->next = prev->next; prev->next = newNode; list->length++; } ``` 6. 获取链表中指定位置的节点值 ```c int get(LinkedList *list, int index) { if (index < 0 || index >= list->length) { printf("Error: index out of range.\n"); return -1; } ListNode *current = list->head; for (int i = 0; i < index; i++) { current = current->next; } return current->data; } ``` 7. 修改链表中指定位置的节点值 ```c void set(LinkedList *list, int index, int data) { if (index < 0 || index >= list->length) { printf("Error: index out of range.\n"); return; } ListNode *current = list->head; for (int i = 0; i < index; i++) { current = current->next; } current->data = data; } ``` 8. 删除链表中指定位置的节点 ```c void deleteAtIndex(LinkedList *list, int index) { if (index < 0 || index >= list->length) { printf("Error: index out of range.\n"); return; } ListNode *deletedNode = NULL; if (index == 0) { deletedNode = list->head; list->head = list->head->next; } else { ListNode *prev = list->head; for (int i = 0; i < index - 1; i++) { prev = prev->next; } deletedNode = prev->next; prev->next = deletedNode->next; } free(deletedNode); list->length--; } ``` 9. 判断链表是否为空 ```c bool isEmpty(LinkedList *list) { return list->head == NULL; } ``` 10. 获取链表的长度 ```c int length(LinkedList *list) { return list->length; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

善程序员文

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值