C语言实现链表（LinkedList）数据结构

最新推荐文章于 2024-07-07 18:26:58 发布
最新推荐文章于 2024-07-07 18:26:58 发布
阅读量1.4k 收藏 19
点赞数 27
分类专栏： 数据结构 文章标签： 数据结构 c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40300093/article/details/136404977
版权

简介

之前的几篇文章都有使用过链表来实现一些数据结构，诸如C语言链表实现队列，C语言链表实现堆栈等，本篇文章就简单介绍一下如何用C语言实现一个简单的单向链表结构，以及一些链表的操作。比起数组来存储数据，链表对删除元素添加元素这些操作更加的灵活。实际上就是把物理上不相邻的内存空间通过“链”的方式链接起来，成为逻辑上相邻的内存空间。

链表操作

  1. 初始化链表：初始化一个链表。
  2. 插入结点：在链表的特定位置（头、尾、或者中间某个位置）插入一个新的结点。
  3. 删除结点：删除链表中特定的结点。
  4. 查找结点：按照特定的条件在链表中查找节点。本篇文章将通过查找第一次出现数据和通过索引的方式查找特定的结点。
  5. 反转链表：改变链表指针的指向。
  6. 获取链表长度：计算链表中结点的个数。
  7. 遍历链表：按照顺序访问链表中的每个结点并对其进行操作，我这里就是打印一下链表的data。
  8. 清空链表：释放链表结点的内存空间。

链表结点

由于是单向链表，所以一般就包含两个变量，一个存储数据的变量，一个指向下一个结点的指针变量。
具体代码示例如下：

// 定义链表结点指针类型
typedef struct StackNode *PStackNode;

// 定义链表结点类型
typedef struct StackNode {
    int data;
    PStackNode next;
} SNode;

链表结构

// 定义链表的结构，以及别名和指针别名
// 结构中有三个变量
// 链表头部head、链表尾部tail、以及索引index
typedef struct {
    PStackNode head;
    PStackNode tail;
    int index;
} LList, *LListPtr;

链表初始化

// 初始化时是一个空的链表所以头尾都是NULL指针
// index从-1开始方便后续查找之类的函数实现
void initLinkedList(LListPtr lListPtr) {
    lListPtr->head = NULL;
    lListPtr->tail = NULL;
    lListPtr->index = -1;
}

	首先看看插入操作，对于空链表插入第一个元素的时候需要做个特殊判断，因为插入结束之后头尾指针指向
同一个结点。所以代码可以这么写：

PStackNode p = (PStackNode) malloc(sizeof(SNode));
if (p) {
	p->data = item;
	if (!lListPtr->tail) {
		// 头尾指针同时指向第一个节点
    	lListPtr->tail = p;
        lListPtr->head = p;
        // 第一个节点的next是NULL
        p->next = NULL;
    }
    
    // 加入结点索引加1
    lListPtr->index++;
}

	处理完空链表添加第一个节点之后的操作，就需要再做两个特殊的操作一个是往链表头部前面添加节点，也
就是让原本的头部结点变成链表中第二个节点。新结点next指向没插入前的头结点，插入结束后新节点就要变成
新的头结点，所以代码可以这么写：

// 其中p是新结点的指针
p->next = lListPtr->head;
lListPtr->head = p;

	还有一个操作就是往链表尾部添加新结点，这个也就比较简单了。只要将tail->next指向新的结点，然后
新结点变成链表的尾部结点并将新节点的next指针指向NULL，所以代码可以这么写：

lListPtr->tail->next = p;
lListPtr->tail = p;
p->next = NULL;

	最后就是从链表中间插入新结点了，这个操作我们只需要知道当前被插入的节点，将新节点的next指针指向
当前被插入结点的next所指的结点，然后将被插入结点的next指针指向新的结点，由于我们链表只知道头尾两
个指针，所以需要做遍历操作，比如我这里是通过传入一个index索引值来查找对应需要插入的结点位置是在哪
里。
具体代码示例如下：

int count = 0;
PStackNode current = lListPtr->head;
while (count < index) {
	current = current->next;
	count++;
}
// 跳出循环，说明此时的current指针指向的就是我们要插入的结点
p->next = current->next;
current->next = p;

	我这里写了三个函数其中两个是特殊情况，从插入结点、插入尾结点，剩下一个是根据index插入对应的结
点位置。具体代码如下：

// 先从链表结尾插入结点
void addNodeOnTail(LListPtr lListPtr, int item) {
    addNodeByIndex(lListPtr, lListPtr->index, item);
}

// 往链表头部前面插入结点
void addNodeOnHead(LListPtr lListPtr, int item) {
    addNodeByIndex(lListPtr, -1, item);
}

// 根据索引插入结点
// 首先判断索引是否合法，规定传入的index意思就是从该index往后插入一个节点
// 此时有个特殊的插入方式就是往头结点前面插入元素，此时可以传入index为-1
// 所以需要特殊判断，还有防止传入的index超过结点的最大索引
// 或者如果插入的结点超过最大索引就认为是插入到尾部结点后面
// 规范点还是限定插入结点的索引好了，即特殊索引就-1一个
// 如果插入结点索引不合法则不插入
// 一开始链表为空的时候需要考虑
void addNodeByIndex(LListPtr lListPtr, int index, int item) {
    // 判断插入结点索引合法性
    if (index < -1 || index > lListPtr->index) {
        printf("待插入结点索引不合法，结点插入失败！！！\n");
    } else {
        PStackNode p = (PStackNode) malloc(sizeof(SNode));
        if (p) {
            p->data = item;
            // 开始为空链表的情况
            if (!lListPtr->tail) {
                lListPtr->tail = p;
                lListPtr->head = p;
                p->next = NULL;
            } else {
                // 处理往头前面以及尾部后面插入结点的特殊情况
                if (index == -1) {
                    p->next = lListPtr->head;
                    lListPtr->head = p;
                } else if (index == lListPtr->index) {
                    lListPtr->tail->next = p;
                    lListPtr->tail = p;
                    // 尾部插入的时候需要添加
                    // 之前忘了，发现无限循环
                    // 打印链表
                    p->next = NULL;
                } else {
                    int count = 0;
                    PStackNode current = lListPtr->head;
                    while (count < index) {
                        current = current->next;
                        count++;
                    }
                    p->next = current->next;
                    current->next = p;
                }
            }
            lListPtr->index++;
            // 调试用
            // printf("this index: %d\n", lListPtr->index);
        } else {
            printf("无法申请到内存空间！！！\n");
        }
    }
}

其实上面这个写法不算好，应该把最后面的函数插入尾部和插入头部的逻辑写在上面两个函数中，再判断如果是特殊的插入尾部或插入头部那么就调用对应的函数，而不是像我这样把它们逻辑写在一起看起来整个函数很复杂。所以后面删除结点的操作我就把各个函数的职责给分离了。

删除操作

和上面的插入的逻辑差不多，不同的是删除是找到对应的位置然后free所申请的内存空间，而插入是找到对应位置然后加入一个新的结点。查找结点的过程就不多赘述可，上面的插入操作也有查找的过程。这里就讲讲几种删除的方式。

删除头部

	由于链表知道头指针所以删除头部其实是很方便的，不需要遍历去找待删除结点。具体操作就是将临时指针
变量先存储一下需要被删除的头部指针，然后头指针指向第二个结点head = head->next。此时需要做一个判断
如果当前链表只有一个结点的话如果删除了头结点也就是链表将要变成空链表的时候需要对尾部指针也做一个赋
值NULL的操作，具体代码如下所示：

// 删除结点好像只有删除头结点需要特殊操作
void deleteNodeOnHead(LListPtr lListPtr) {
    if (lListPtr->head) {
        PStackNode p = lListPtr->head;
        lListPtr->head = lListPtr->head->next;
        if (NULL == lListPtr->head) {
            lListPtr->tail = NULL;
        }
        free(p);
        lListPtr->index--;
    }
}

删除其他位置

除了删除头部节点是特殊的操作，其他的删除操作都可以通过下面的函数执行删除。

void deleteNodeByIndex(LListPtr lListPtr, int index) {
    // 删除头结点
    if (index == 0) {
        deleteNodeOnHead(lListPtr);
        // 这里的判断条件可以保证传入的不是空链表
        // 比如此时如果传入一个空链表那么lListPtr->index此时为-1
        // 不管传入的index是什么值，条件都进不去
        // 只有链表不为空的时候才能进入条件
    } else if (index <= lListPtr->index && index > 0) {
        // 删除index对应索引的下标
        // 执行删除操作需要两个指针一个为待删除结点
        // 一个为指向待删除结点的前一个节点
        // 所以这里用两个变量current、perv来表示
        PStackNode current = lListPtr->head;
        PStackNode perv = NULL;
        int count = 0;
        while (count < index) {
            perv = current;
            current = current->next;
            count++;
        }

        // 前一个节点指向当前要删除结点的后面
        perv->next = current->next;
        free(current);
        lListPtr->index--;
    } else {
        printf("需要删除的结点不存在\n");
    }
}

同时还提供了一个编辑删除尾部的操作

// 提供一个便捷删除尾部结点的操作
void deleteNodeOnTail(LListPtr lListPtr) {
	// 输入当前链表的最大索引值，删除尾部结点
    deleteNodeByIndex(lListPtr, lListPtr->index);
}

查找结点

我这里通过索引值和数据值两个方式来获取结点的指针，具体操作因为比较好理解所以直接贴代码了

// 返回第一个数据值匹配结点指针，没找到时返回NULL
PStackNode getNodeByData(LListPtr lListPtr, int data) {
    PStackNode ret = NULL;

    for (PStackNode p = lListPtr->head; p; p = p->next) {
        if (p->data == data) {
            ret = p;
            break;
        }
    }

    return ret;
}

// 返回索引所对应的结点指针，没找到时返回NULL
PStackNode getNodeByIndex(LListPtr lListPtr, int index) {
    PStackNode ret = NULL;

    // 输入的索引在对应链表的范围内才能返回对应的指针
    if (0 < index && index < lListPtr->index) {
        int count = 0;
        PStackNode p = lListPtr->head;
        // 如果进入循环
        // 那么count == index 时条件退出
        // 此时p就是我们要找的结点指针
        while (count < index) {
            p = p->next;
            count++;
        }
        ret = p;
    } else if (0 == index) {
        ret = lListPtr->head;
    } else if (lListPtr->index == index) {
        ret = lListPtr->tail;
    }

    return ret;
}

获取链表长度

因为我们一开始就用了index索引值来表示链表此时最大的索引，由于index从0开始每次插入结点时加1，删除结
点时减1，所以获取长度代码如下：

int getLinkedListLength(LListPtr lListPtr) {
    return lListPtr->index + 1;
}

反转链表

意思就是将链表头变成尾部，尾部变成头部，其他位置的指针指向都变成反方向，比如结点A开始指向结点B，反
转之后节点B指向结点A这样。

// 反转链表操作
void reverseLinkedList(LListPtr lListPtr) {
	// 需要三个指针
	// 前一个结点、当前结点、下一个结点
	// prev、current、next
    PStackNode prev = NULL;
    PStackNode current = lListPtr->head;
    PStackNode next = NULL;

	// 遍历链表
    while (current) {
    	// 下一个结点时当前结点的next很好理解吧
        next = current->next;
        
        // 由于需要反转此时当前的结点就要指向它前面一个节点
        // A->B 变成 A<-B这样
        current->next = prev;
        // 处理完上面之后下一次循环的前一个结点就是当前结点
        // 所以
        prev = current;

		// 当前结点向后移动
        current = next;
    }

    // 如果如果循环执行了，那么结束之后prev指向链表的反转之后的头部
    // 原来的链表尾部变成头部结点
    lListPtr->tail = lListPtr->head;
    lListPtr->head = prev;
}

遍历链表

这个操作也很好理解，从头指向尾，所以需要一个临时指针保存一下头结点的位置，具体代码如下所示：

    for (PStackNode p = lListPtr->head; p; p = p->next) {
    	// do something
    	// 我这里只是打印了结点的值
        printf("%d ", p->data);
    }

	// 用while来写就是
	PStackNode p = lListPtr->head
	while(p)
	{
		// do something
		p = p->next;
	}

清空链表

由于链表的结点都是malloc动态申请到的内存空间，所以不需要使用的时候需要清空一下链表，其实和遍历操作
很像，具体代码如下：

void clearLinkedList(LListPtr lListPtr) {
    for (PStackNode p = lListPtr->head, q = NULL; p; p = q) {
    	// 只不过每次free操作之后p指向什么都不知道了
    	// 所以需要提前保存一下当前p结点的下一个结点
    	// 这里用q来保存
    	// 每次循环结束之后p=q
        q = p->next;
        free(p);
    }

    // 清空一下链表的几个数据
    // 防止二次调用该函数出现不安全的内存访问
    initLinkedList(lListPtr);
}

完整代码

完整代码我也会贴出来，提供给有需要的同学作参考。
头文件single_linked_list.h

#ifndef C_SINGLE_LINKED_LIST_H
#define C_SINGLE_LINKED_LIST_H

#include "linked_list_stack.h"

typedef struct {
    PStackNode head;
    PStackNode tail;
    int index;
} LList, *LListPtr;

void initLinkedList(LListPtr lListPtr);

int getLinkedListLength(LListPtr lListPtr);

void addNodeOnTail(LListPtr lListPtr, int item);

void addNodeOnHead(LListPtr lListPtr, int item);

void addNodeByIndex(LListPtr lListPtr, int index, int item);

PStackNode getNodeByData(LListPtr lListPtr, int data);

PStackNode getNodeByIndex(LListPtr lListPtr, int index);

void deleteNodeOnHead(LListPtr lListPtr);

void deleteNodeByIndex(LListPtr lListPtr, int index);

void deleteNodeOnTail(LListPtr lListPtr);

void printLinkedList(LListPtr lListPtr);

void reverseLinkedList(LListPtr lListPtr);

void clearLinkedList(LListPtr lListPtr);

void linkedListTest(void);

#endif //C_SINGLE_LINKED_LIST_H

代码文件single_linked_list.c

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

//typedef struct {
//    PStackNode head;
//    PStackNode tail;
//} LList, *LListPtr;

void initLinkedList(LListPtr lListPtr) {
    lListPtr->head = NULL;
    lListPtr->tail = NULL;
    lListPtr->index = -1;
}

int getLinkedListLength(LListPtr lListPtr) {
    return lListPtr->index + 1;
}

// 先从链表结尾插入结点
void addNodeOnTail(LListPtr lListPtr, int item) {
    addNodeByIndex(lListPtr, lListPtr->index, item);
}

// 往链表头部前面插入结点
void addNodeOnHead(LListPtr lListPtr, int item) {
    addNodeByIndex(lListPtr, -1, item);
}

// 根据索引插入结点
// 首先判断索引是否合法，规定传入的index意思就是从该index往后插入一个节点
// 此时有个特殊的插入方式就是往头结点前面插入元素，此时可以传入index为-1
// 所以需要特殊判断，还有防止传入的index超过结点的最大索引
// 或者如果插入的结点超过最大索引就认为是插入到尾部结点后面
// 规范点还是限定插入结点的索引好了，即特殊索引就-1一个
// 如果插入结点索引不合法则不插入
// 一开始链表为空的时候需要考虑
void addNodeByIndex(LListPtr lListPtr, int index, int item) {
    // 判断插入结点索引合法性
    if (index < -1 || index > lListPtr->index) {
        printf("待插入结点索引不合法，结点插入失败！！！\n");
    } else {
        PStackNode p = (PStackNode) malloc(sizeof(SNode));
        if (p) {
            p->data = item;
            // 开始为空链表的情况
            if (!lListPtr->tail) {
                lListPtr->tail = p;
                lListPtr->head = p;
                p->next = NULL;
            } else {
                // 处理往头前面以及尾部后面插入结点的特殊情况
                if (index == -1) {
                    p->next = lListPtr->head;
                    lListPtr->head = p;
                } else if (index == lListPtr->index) {
                    lListPtr->tail->next = p;
                    lListPtr->tail = p;
                    // 尾部插入的时候需要添加
                    // 之前忘了，发现无限循环
                    // 打印链表
                    p->next = NULL;
                } else {
                    int count = 0;
                    PStackNode current = lListPtr->head;
                    while (count < index) {
                        current = current->next;
                        count++;
                    }
                    p->next = current->next;
                    current->next = p;
                }
            }
            lListPtr->index++;
            // 调试用
            // printf("this index: %d\n", lListPtr->index);
        } else {
            printf("无法申请到内存空间！！！\n");
        }
    }
}

PStackNode getNodeByData(LListPtr lListPtr, int data) {
    PStackNode ret = NULL;

    for (PStackNode p = lListPtr->head; p; p = p->next) {
        if (p->data == data) {
            ret = p;
            break;
        }
    }

    return ret;
}

PStackNode getNodeByIndex(LListPtr lListPtr, int index) {
    PStackNode ret = NULL;

    // 输入的索引在对应链表的范围内才能返回对应的指针
    if (0 < index && index < lListPtr->index) {
        int count = 0;
        PStackNode p = lListPtr->head;
        while (count < index) {
            p = p->next;
            count++;
        }
        ret = p;
    } else if (0 == index) {
        ret = lListPtr->head;
    } else if (lListPtr->index == index) {
        ret = lListPtr->tail;
    }

    return ret;
}

// 删除结点好像只有删除头结点需要特殊操作
void deleteNodeOnHead(LListPtr lListPtr) {
    if (lListPtr->head) {
        PStackNode p = lListPtr->head;
        lListPtr->head = lListPtr->head->next;
        if (NULL == lListPtr->head) {
            lListPtr->tail = NULL;
        }
        free(p);
        lListPtr->index--;
    }
}

// 提供一个便捷删除尾部结点的操作
void deleteNodeOnTail(LListPtr lListPtr) {
    deleteNodeByIndex(lListPtr, lListPtr->index);
}

void deleteNodeByIndex(LListPtr lListPtr, int index) {
    // 删除头结点
    if (index == 0) {
        deleteNodeOnHead(lListPtr);
    } else if (index <= lListPtr->index && index > 0) {
        // 删除index对应索引的下标
        PStackNode current = lListPtr->head;
        PStackNode perv = NULL;
        int count = 0;
        while (count < index) {
            perv = current;
            current = current->next;
            count++;
        }

        // 前一个节点指向当前要删除结点的后面
        perv->next = current->next;
        free(current);
        lListPtr->index--;
    } else {
        printf("需要删除的结点不存在\n");
    }
}

// 将链表打印出来
void printLinkedList(LListPtr lListPtr) {
    for (PStackNode p = lListPtr->head; p; p = p->next) {
        printf("%d ", p->data);
    }
}

// 反转链表操作
void reverseLinkedList(LListPtr lListPtr) {
    PStackNode prev = NULL;
    PStackNode current = lListPtr->head;
    PStackNode next = NULL;

    while (current) {
        next = current->next;
        current->next = prev;
        prev = current;

        current = next;
    }

    // 如果如果循环执行了，那么结束之后prev指向链表的反转之后的头部
    // 原来的链表尾部变成头部结点
    lListPtr->tail = lListPtr->head;
    lListPtr->head = prev;
}

void clearLinkedList(LListPtr lListPtr) {
    for (PStackNode p = lListPtr->head, q = NULL; p; p = q) {
        q = p->next;
        free(p);
    }

    // 清空一下链表的几个数据
    // 防止二次调用该函数出现不安全的内存访问
    initLinkedList(lListPtr);
}

void linkedListTest() {
    LList list;
    LListPtr listPtr = &list;
    initLinkedList(listPtr);
    printf("before: \n");
    for (int i = 0; i < 5; ++i) {
        if (i == 0) {
            printf("item nums: \n");
        }
        int item = rand() % 101;
        printf("%d ", item);
        if (i + 1 == 5) {
            printf("\n");
        }
//        addNodeOnHead(listPtr, item);
        addNodeOnTail(listPtr, item);
    }
//    addNodeByIndex(listPtr, -1, rand() % 101);
//    deleteNodeOnHead(listPtr);
//    deleteNodeByIndex(listPtr, 4);
//    deleteNodeOnTail(listPtr);
    printf("%d \n", getNodeByIndex(listPtr, 0)->data);

    printLinkedList(listPtr);
//    reverseLinkedList(listPtr);
//    printf("\n");
//    printf("after: \n");
//    printLinkedList(listPtr);
//    clearLinkedList(listPtr);
}

测试函数输出

测试函数结果

总结

单向链表的一些操作就是上面这些，这里实现了一个简单的单向链表，希望可以帮助你对如何用C语言实现单向链表加深理解。上面这些也只是我在学习数据结构时敲的一些简单代码，如果有什么错误希望能在评论区指出来，毕竟我也是一个初学者，也可能会犯错。感谢你能看到这里。后续如果有时间可能还会考虑双向链表的实现。

YeZLeaf
关注
  • 27
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【C语言】链表入门（配图）
2301_77133706的博客
03-22 1779
本人对于C语言中链表的浅层认识
链表LinkedList
invisibleI的博客
06-08 337
简介 LinkedList 特点 双向链表实现 元素时有序的，输出顺序与输入顺序一致 允许元素为 null 要找到某个结点，必须从头开始遍历。（查询慢，增删快） 和 ArrayList 一样，不是同步容器 基本函数
链表(LinkedList) C 语言实现
热门推荐
song_hui_xiang
07-24 1万+
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。如图： 下面是代码实现： #include #include struct student { int score; struct student *next; }; typedef struct student NODE; //typedef为C语言的关
c语言 linked list
Just Code it
05-05 4198
MyLinkList.h #include #include #define NEW (struct node *)malloc(sizeof(struct node)) struct node { char name[20]; char tel[9]; struct node *next; }; /* 创建 linked list */ stru
C语言实现LinkedList
03-21
C语言实现LinkedList
linklist c语言,C语言实现单链表（LinkedList）
weixin_39795845的博客
05-19 839
采用Linux内核链表的实现思想，通过业务节点包含链表节点来将数据串起来。linkedList.h#ifndef LINKED_LIST_H#define LINKED_LIST_H#include#include#includetypedef struct LinkedListNodeStruct {struct LinkedListNodeStruct *next;}LinkedListNod...
C语言实现单链表（LinkedList）
weixin_33826268的博客
11-25 333
采用Linux内核链表的实现思想，通过业务节点包含链表节点来将数据串起来。linkedList.h #ifndef LINKED_LIST_H #define LINKED_LIST_H #include<stdio.h> #include<stdlib.h> #include<memory.h> typedef struct LinkedListNodeSt...
C语言实现LinkedList链表数据结构
愤怒的苹果ext的博客
11-15 4727
链表基本的就是一个数据域一个指针域，数据域存储你的数据，指针域就指向你下一个节点的内存地址。示意图(画的很粗糙,请见谅) 链表的特点： 增删快 (修改元素时，只需要改变指针域指向就可以了) 查询慢 (元素之前内存地址不连续，只能挨个挨个遍历查找) 我们现在就来实现一个非循环单链表 首先写出链表的结构体： typedef struct Node{ //非循环单链表结构体 int data;
常见数据结构与算法C语言实现
05-04
内容包含常见基本数据结构实现（C语言版）如各自排序、链表、栈、队列、各种树以及应用、图算法、字符串匹配算法、回溯、并查集等 以及包含各个数据结构常见算法题的解答（C语言版） bitTree 二叉搜索树 ...
数据结构 C语言实现循环单链表的实例
08-30
数据结构 C语言实现循环单链表的实例 数据结构是计算机科学中的一门重要学科，它研究的是数据的存储、表示和操作的方法。在计算机科学中，数据结构是指数据的组织、存储和操作的方法。循环单链表是一种常见的数据...
链表c代码实现
10-22
该代码实现了线性表的链式存储，包括创建线性表、删除线性表、清空线性表、插入元素、删除元素等API函数
python数据结构之链表详解
09-21
链表是一种重要的数据结构，它在计算机科学中被广泛用于组织和管理数据。与数组不同，链表不依赖于连续的内存空间，而是通过节点之间的引用连接。在Python中，虽然没有像C语言那样的指针，但我们可以使用对象引用来...
C语言数据结构全部算法.zip
06-16
Java的集合框架（Collection Framework）同样提供了丰富的数据结构实现，如ArrayList、LinkedList、HashMap等。Python的内建数据结构和强大的第三方库（如NumPy、Pandas等）为数据处理提供了强大的工具。 这个...
链表（Linked List）的C语言实现
乘风破浪会有时
08-20 7057
链表中的各对象按线性顺序排列，而其顺序是由各个对象里的指针所决定的。 链表有多种形式，它可以是单链接的或者双链接的，可以是已排序的或未排序的，可以是循环的或非循环的。 定义的结构体以及函数如下：typedef struct ITEM { int key; void * statellite; } item_t; typedef struct NODE { struct N
黑马程序员————LinkedList和c语言中的链表
LeonWenBo的专栏
09-05 2998
最近学习java常常和大一学习的c语言互相印证，待看到
C++链表linked list(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-10 725
C++链表linked list链表linked list算法的完整源码（定义，实现，main函数测试） 链表linked list算法的完整源码（定义，实现，main函数测试） #include <iostream> #include <memory> #include <string> /** * @namespace data_structures * @brief Data Structures algorithms */ namespace data_s
C++实现链表类LinkedList（包括插入节点函数、删除节点函数、创建链表函数、查找函数、打印链表函数、反转链表函数、删除链表倒数第N个节点函数等）
fzy2003的博客
03-25 3700
C++实现链表类LinkedList。节点类ListNode定义和链表类LinkedList声明已给出，需实现插入节点函数、删除节点函数、创建链表函数、查找函数、打印链表函数、反转链表函数、删除链表倒数第N个节点函数、查找链表中间节点、链表升序排序函数、删除排序链表中的重复元素函数。 代码实现如下： #include<iostream> #include<algorithm> using namespace std; class ListNode { public: ListNod
C++：使用本章中的链表类模板，声明两个int类型的链表a,b,分别插入5个元素，然后把b中元素加入a的尾部
m0_64594973的博客
11-11 1244
c++语言程序设计第五版，郑莉，第九章模板与群体数据中习题9-5的一个题目
数据结构第14节 加权图
最新发布
hummhumm的专栏
07-07 1327
( V ) 是顶点的集合。( E ) 是边的集合，每条边连接 ( V ) 中的一对顶点。( W ) 是一个函数，将每条边映射到一个实数上，即 ( W: E \rightarrow \mathbb{R} )。
造一个c语言完整链表
05-09
链表是一种常见的数据结构，由多个节点组成，每个节点包含数据和指向下一个节点的指针。实现一个完整的链表包括以下几个步骤： 1. 定义节点结构体 ``` typedef struct Node { int data; struct Node *next; }...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值