Linked List的基本操作（创建/删除/插入/查找）

最新推荐文章于 2024-10-08 14:22:32 发布
最新推荐文章于 2024-10-08 14:22:32 发布
阅读量3k 收藏 3
点赞数
分类专栏： 数据结构 文章标签： 数据结构 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Timsley/article/details/53312112
版权

Linked list这种数据结构，主要用于对数据进行操作。链表长成下面这样，由多个节点串起来，每个节点有两个域，一个是数据域（用于存储你的数据），一个是指针域（用于存储指向下一个节点的指针），最后一个节点一般指向NULL。

这里写图片描述

那么再看下面这张图

这里写图片描述

从上图可以看出，每个节点之间的地址不是连续的，这个地址是由系统分配的（用malloc创建节点的时候，系统会给该节点分配内存，而每一块内存都有对应的地址）。如a1的指针域是800，而a2的起始地址是800，说明a1的下一个节点就是a2，以此类推，a4的下一个节点是a5，a5是最后一个节点（一般系统会默认NULL为0地址，而a5的指针域指向的是0）

链表基本操作有创建/插入/删除/查找，下面，用两张图来说明插入和删除的操作原理：

这里写图片描述

这里写图片描述

有些人为了方便链表的操作，经常会给链表添加一个头结点做处理，见下图

这里写图片描述

至于头结点的意义在哪里，详见 链表头结点存在的意义

下面我们就直接看代码的实现

linked_list.c
#include <stdio.h>
#include <stdlib.h>
#include "typedef.h"
#include "linked_list.h"

LINK_LIST_T link_list_init(VOID)
{
    LINK_LIST_T pList = (LINK_LIST_T)malloc(sizeof(NODE_T)); 
    if(!pList)
    {
        printf("link_list_init malloc failed! \n");
        return NULL;
    }

    pList->next = NULL;

    return pList;
}

BOOL link_list_is_empty(LINK_LIST_T pList)
{    
    LINK_LIST_CHK_FAIL(pList, TRUE);

    return pList->next == NULL;
}

BOOL link_list_is_last(ElementType element, LINK_LIST_T pList)
{
    LINK_LIST_CHK_FAIL(pList, FALSE);

    LINK_LIST_T pTemp = pList;

    while(pTemp->next != NULL)      // fine the last node
        pTemp = pTemp->next;

    if(pTemp->element == element)
        return TRUE;
    else 
        return FALSE;
}

/****************************************************************************
***
*** Check the element in the list or not, if find, return TRUE, if not find, return FALSE
***
****************************************************************************/
BOOL link_list_find_element(ElementType element, LINK_LIST_T pList)
{
    LINK_LIST_CHK_FAIL(pList, FALSE);

    LINK_LIST_T pTemp = pList->next;

    while(pTemp)
    {
        if(pTemp->element == element)
            return TRUE;
        pTemp = pTemp->next;
    }

    return FALSE;
}

/****************************************************************************
***
*** Check the element in the list or not, if find, return the index, if not find, return 0
***
****************************************************************************/
INT32 link_list_find_element_ret_index(ElementType element, LINK_LIST_T pList)
{
    LINK_LIST_CHK_FAIL(pList, LISTR_FAIL);

    LINK_LIST_T pTemp = pList->next;
    INT32 index = 0;

    while(pTemp)
    {
        index++;
        if(pTemp->element == element)
            return index;
        pTemp = pTemp->next;
    }

    return 0;
}

/****************************************************************************
***
***  Find the element by the index, if find, it can get the element, if not, return FALSE
***
****************************************************************************/
BOOL link_list_find_by_index(ElementType *element, INT32 index, LINK_LIST_T pList)
{
    LINK_LIST_CHK_FAIL(pList, FALSE);

    LINK_LIST_T pTemp = pList->next;
    INT32 i = 1;

    while(pTemp && i<index)
    {
        pTemp = pTemp->next;
        i++;
    }

    if(!pTemp || i>index)
    {
        printf("Cannot find the index, invalid args!\n");
        return FALSE;
    }

    *element = pTemp->element;

    return TRUE;
}

POSITION link_list_find_previous(ElementType element, LINK_LIST_T pList)
{
    LINK_LIST_CHK_FAIL(pList, NULL);

    LINK_LIST_T pTemp = pList;
    LINK_LIST_T qTemp =  pTemp;

    while(pTemp && pTemp->element != element)
    {
        qTemp = pTemp;
        pTemp = pTemp->next;
    }

    if(!pTemp)
    {
        printf("Cannot find the element in the list!\n");
        return NULL;
    }

    return qTemp;
}

INT32 link_list_insert_at_tail(ElementType element, LINK_LIST_T pList)
{
    LINK_LIST_CHK_FAIL(pList, LISTR_FAIL);

    LINK_LIST_T pTemp = pList;

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

    LINK_LIST_T node = (LINK_LIST_T)malloc(sizeof(NODE_T));
    if(!node)
    {
        printf("link_list_insert_at_tail malloc failed! \n");
        return LISTR_FAIL;
    }

    node->element = element;
    node->next = NULL;

    pTemp->next= node;   

   return LISTR_OK;
}

INT32 link_list_insert_at_head(ElementType element, LINK_LIST_T pList)
{
    LINK_LIST_CHK_FAIL(pList, LISTR_FAIL);

    LINK_LIST_T pTemp = pList;
    LINK_LIST_T pNext = pList->next;

    LINK_LIST_T node = (LINK_LIST_T)malloc(sizeof(NODE_T));
    if(!node)
    {
        printf("link_list_insert_at_head malloc failed! \n");
        return LISTR_FAIL;
    }

    node->element = element;
    node->next = pNext;

    pTemp->next= node;   

    return LISTR_OK;
}

INT32 link_list_insert_by_index(ElementType element, INT32 index, LINK_LIST_T pList)
{
    LINK_LIST_CHK_FAIL(pList, LISTR_FAIL);

    LINK_LIST_T pTemp = pList;
    INT32 i = 1; 

    while(pTemp && i<index)
    {
        pTemp = pTemp->next;
        i++;
    }

    if(!pTemp || i>index)
    {
        printf("The index is not exist! \n");
        return LISTR_FAIL;        
    }

    LINK_LIST_T node = (LINK_LIST_T)malloc(sizeof(NODE_T));
    if(!node)
    {
        printf("link_list_insert_at_head malloc failed! \n");
        return LISTR_FAIL;
    }

    node->element = element;
    node->next = pTemp->next;
    pTemp->next = node;

    return LISTR_OK;
}

INT32 link_list_delete_by_index(ElementType *element, INT32 index, LINK_LIST_T pList)
{
    LINK_LIST_CHK_FAIL(pList, LISTR_FAIL);

    LINK_LIST_T pTemp = pList;
    LINK_LIST_T qTemp;
    INT32 i=1;

    while(pTemp->next && i<index)
    {
        pTemp = pTemp->next;
        i++;
    }

    if(pTemp->next == NULL || i>index)
    {
        printf("The index is not exist\n");
        return LISTR_FAIL;
    }

    qTemp = pTemp->next;
    *element = qTemp->element;
    pTemp->next = qTemp->next;

    free(qTemp);

    return LISTR_OK;
}

INT32 link_list_get_list_len(LINK_LIST_T pList)
{    
    LINK_LIST_CHK_FAIL(pList, LISTR_FAIL);

    LINK_LIST_T pTemp = pList;
    INT32 len = 0;

    if(!pList)
    {
        printf("The link list is uninit, pls init it\n");
        return LISTR_FAIL;
    }

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

    return len;
}

INT32 link_list_uninit(LINK_LIST_T pList)
{
    LINK_LIST_T pTemp;

    while(pList)
    {        
        pTemp = pList->next;
        free(pList);
        pList = pTemp;
    }

    return LISTR_OK;
}

VOID link_list_traverse(LINK_LIST_T pList)
{
    LINK_LIST_CHK_FAIL(pList, (void)LISTR_FAIL);

    LINK_LIST_T pTemp = pList->next;

    while(pTemp != NULL)
    {
        printf("node->element : %d\n", pTemp->element);
        pTemp = pTemp->next;
    }
}


VOID link_list_main_test(VOID)
{
    INT32 i;
    LINK_LIST_T pList = link_list_init();

    for(i=1; i<=10; i++)
        link_list_insert_at_tail(i, pList);

    link_list_traverse(pList);    

    if(pList)
    {
        link_list_uninit(pList);
    }
}
linked_list.h
#ifndef __LINKED_LIST_H__
#define __LINKED_LIST_H__

typedef int ElementType;

typedef struct _NODE_T
{
    ElementType element;
    struct _NODE_T *next;
}NODE_T;

typedef struct _NODE_T * LINK_LIST_T;
typedef struct _NODE_T * POSITION;

#define LISTR_OK                              ((INT32)0)
#define LISTR_FAIL                            ((INT32)-1)

#define LINK_LIST_CHK_FAIL(argu, value)     if(!(argu)) {printf("<LINK_LIST> ERR : func=%s, line=%d, argument="#argu".\n", __func__, __LINE__); return value;}


extern LINK_LIST_T link_list_init(VOID);
extern BOOL link_list_is_empty(LINK_LIST_T pList);
extern BOOL link_list_is_last(ElementType element, LINK_LIST_T pList);
extern BOOL link_list_find_element(ElementType element, LINK_LIST_T pList);
extern INT32 link_list_find_element_ret_index(ElementType element, LINK_LIST_T pList);
extern BOOL link_list_find_by_index(ElementType *element, INT32 index, LINK_LIST_T pList);
extern POSITION link_list_find_previous(ElementType element, LINK_LIST_T pList);
extern INT32 link_list_insert_at_tail(ElementType element, LINK_LIST_T pList);
extern INT32 link_list_insert_at_head(ElementType element, LINK_LIST_T pList);
extern INT32 link_list_insert_by_index(ElementType element, INT32 index, LINK_LIST_T pList);
extern INT32 link_list_delete_by_index(ElementType *element, INT32 index, LINK_LIST_T pList);
extern INT32 link_list_get_list_len(LINK_LIST_T pList);
extern INT32 link_list_uninit(LINK_LIST_T pList);
extern VOID link_list_traverse(LINK_LIST_T pList);
extern VOID link_list_main_test(VOID);

#endif

PS：本文所用的图片全都引用自《数据结构与算法分析C语言描述 第2版》第三章

Timsley
关注
专栏目录
链表(LinkList)数据结构的基本操作实现详解，纯干货
HenryBlog
08-19 6012
目录一、前言二、整体设计框架三、函数实现1. createLSTNode2. linkListPushBack4. linkListPrint5. linkListDestory6. linkListSize7. linkListEmpty8. linkListPushFront9. linkListPopBack10. linkListPopFront11. linkListNodeFind12. linkListInsert13. linkListErase四、完整代码 一、前言 本篇主要实现链表的一些
Java LinkList：动态添加或删除元素的最佳选择
qq_28245087的博客
05-24 558
LinkedList是Java中的一个双向链表结构的容器，它实现了List和Deque接口，因此可以被当作普通的List或双端队列来使用。LinkedList使用链表实现，可以根据需要动态地增加或删除元素，因此它的容量大小不固定。与ArrayList相比，它提供了更多的操作方法，但是访问数据需要遍历整个链表，因此在访问元素时速度相对较慢。LinkedList是Java中一个非常实用的数据结构，它可以根据需要动态地添加或删除元素，提供了更多的操作方法，可以实现队列、栈和LRU缓存等算法。
LinkedList 的简单操作 ：插入 删除 正序、逆序遍历
白鱼的博客
08-16 2764
package test812.night;import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.ListIterator;public class Test2 {public static void main(String[] args) { //
数据结构之链表
最新发布
听老罗娓娓道来
10-08 1390
链表（Linked List）是一种常见的数据结构，它由一系列节点（Node）组成，每个节点包含两部分：数据域和指针域。数据域用于存储数据，而指针域则存储指向下一个节点的引用（或指针）。链表的最后一个节点的指针域通常指向空（NULL），表示链表的结束。通过上述方法，可以在一定程度上解决链表面临的性能问题。在实际应用中，应根据具体需求和场景选择合适的优化策略。合理利用这些技巧，可以充分发挥链表的优势，提高程序的整体性能和可维护性。通过上述方法，可以在一定程度上进一步降低链表的时间和空间复杂度。
LinkedList的删除结点操作(golang)
liyong561的博客
04-03 290
LinkedList的删除结操作 func removeNthFromEnd(head *ListNode, n int) *ListNode { // 链表，从头结点遍历 cur :=head length:=0 for cur !=nil{ length++ // 为什么这样不能删除结点 cur = cur.Next } dummy:=&ListNode{0,head} cur =dumm
LinkedList的各种操作插入删除操作一张图搞定
本人的技术和文笔有限，正在努力成长中，请各位朋友多多指正与包涵！
06-09 758
LinkedList是一个双向链表，一般用它来作为队列使用，特别是算法题中经常会用到它。下图是LinkedList中各种插入和删除操作对应的执行位置。 add：从尾巴插入 remove、poll、pop：从头取出 push：从头插入 removeLast、pollLast：从尾取出 Tips: LinkedList：可作为队列使用（线程不安全） PriorityQueue：可作为堆使用（默认小根堆；线程不安全） Stack：栈 ArrayDeque：队列 / 栈（速度优于LinkedList和St
链表Linked List-插入的3种方法（9）
weixin_45428910的博客
02-25 970
链表Linked List-插入的3种方法（9）
单链表的建立、插入、删除、查找.rar_单链表的建立、插入、删除、查找_插入删除
09-23
Node* createLinkedList(int arr[], int size) { Node* head = nullptr; Node* tail = nullptr; for (int i = 0; i ; ++i) { Node* newNode = new Node(); newNode->data = arr[i]; newNode->next = nullptr;...
linked-list:C用于单链表和双链表
05-12
linked-list C for single linked list and double linked list single_list 结点结构体 创建结点 创建链表 显示链表的数据 获取链表长度 插入结点 删除结点 查找链表中指定的数据 修改链表中指定位置结点的值 修改...
Linked List的相关操作
江东小熊熊
10-28 250
//--------------------------Linked_List---------------------------- //类声明 typedef int ElementType; class List { private: class Node { public: ElementType data; Node *next; Node(ElementType va
JavaScript 双向链表操作实例分析【创建、增加、查找、删除等】
10-15
下面我们将深入分析JavaScript中双向链表的基本操作，包括创建、增加、查找、插入和删除节点。 1. **创建双向链表** 双向链表通常由一个头节点（head）开始，头节点的`prev`属性指向null，表示链表的起点。可以...
LinkedList基本操作
GaoChenXi
05-05 359
一 、概述       LinkedList与ArrayList一样实现List接口，只是ArrayList是List接口的大小可变数组的实现，LinkedList是List接口链表的实现。基于链表实现的方式使得LinkedList在插入和删除时更优于ArrayList，而随机访问则比ArrayList逊色些。       LinkedList实现所有可选的列表操作，并允许所有的元
java linkedlist 查找_用LinkedList如何实现搜索指定对象的元素
weixin_29793473的博客
02-16 966
该楼层疑似违规已被系统折叠隐藏此楼查看此楼importstaticjava.lang.System.out;importjava.util.*;publicclassTestLinkedList{publicstaticvoidmain(String[]args){LinkedListlist=newLinkedList();list.add("JohnAlex");...
数据结构linklist实现添加、插入、删除元素
weixin_46529416的博客
10-18 1045
【代码】数据结构linklist实现添加、插入元素。
Linked List - Insert, Remove
feibafeibalala的博客
11-19 299
Main.java public class Main { public static void main(String[] args) { LinkedList206<String> lnl = new LinkedList206<>(); lnl.add("Kaipo"); lnl.add("Han"); lnl.add("Rex"); lnl...
JDK8:HashMap
fhxyryxc的博客
12-31 117
数组+链表+红黑树 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 static final int MAXIMUM_CAPACITY = 1 << 30; static final float DEFAULT_LOAD_FACTOR = 0.75f; static final int TREEIFY_THRESHOLD = 8; static final int UNTREEIFY_THRESHOLD =
circular_linked_list_4_6.zip_Linked list
09-19
环形链表支持多种操作，如插入节点、删除节点、遍历链表等。由于环形结构，这些操作需要特别注意边界条件。 - 插入节点：可以在链表的任何位置插入节点，包括链表头部和尾部（链表中的任意节点）。 - 删除节点：...
Linked List
轻描时光
01-14 92
Linked List 链表即是由节点（Node）组成的线性集合，每个节点可以利用指针指向其他节点。它是一种包含了多个节点的、能够用于表示序列的数据结构。 单向链表: 链表中的节点仅指向下一个节点，并且最后一个节点指向空。 双向链表: 其中每个节点具有两个指针 p、n，使得 p 指向先前节点并且 n 指向下一个节点；最后一个节点的 n 指针指向 null。 循环链表：每个节点指向下一个节点...
链表Linklist操作
m0_74937538的博客
09-09 251
单向循环链表:约瑟夫环问题，是一个经典的循环链表问题，题意是：已知 n 个人（分别用编号 1，2，3，…顺序表在内存当中连续存储的(数组)，但是链表在内存当中是不连续存储的，通过指针将数据链接在一起。删除单向链表中出现的指定数据,data代表将单向链表中出现的所有data数据删除。顺序表查找方便，但是插入和删除效率低，链表，插入和删除方便，查找效率低。思想：用头指针移动到要杀的猴子的前一个，然后跨过指向猴子的节点。删除单向链表中指定位置的数据 post 代表的是删除的位置。合并，形成一个递增有序的新链表。
Java 用链表实现线性表（LinkList）增、删、查、遍历等
qq_41025410的博客
02-15 1030
Java 用链表实现线性表（LinkList）增、删、查、遍历等
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值