数据结构 单链表 C++ 实现

已于 2022-07-30 21:46:42 修改
阅读量3.5k 收藏 34
点赞数 8
分类专栏： 数据结构与算法 文章标签： c++
于 2022-03-25 10:26:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52423355/article/details/123729201
版权

目录

单链表

单链表的定义

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

此处 LNode 强调一个结点，*LinkList 强调一个单链表的头指针，本例中只有头指针使用 *LinkList ；

单链表的头指针和头节点

若单链表没有头节点，那么单链表的头指针则指向链表的第一个元素；若有头节点，头指针指向头节点；例如头指针为 L；如果链表为空，则有 L == NULL，若有头节点，则有 L->next = NULL；

注意此处的指向问题应当透彻理解指针的概念，指向理解为元素地址；此处的 L 为头指针；在没有头节点时指向第一个元素，L 就是第一个元素的地址，若没有元素，即没有第一个元素，那么 L == NULL；如果有头节点，那么 L 为头节点的地址，因此 L->next 即为元素的第一个结点，故当链表为空时 L->next == NULL；

本例中的单链表均为带头节点的单链表；

初始化一个单链表

初始化单链表的主要目的在于建立一个头节点，并让 L 指向头节点；

L = (LinkList)malloc(sizeof(LNode)) 此处申请一个头节点的空间并返回申请到空间的地址返回，必须传入 L 的引用或者二级指针；

若直接传入 L 那么将会拷贝一份 L 指针给 L1 ，那么申请到的空间地址将返回给 L1 而不是L。
详见 单链表中的头指针初始化问题

因此必须传入 L 的引用或者 L 的指针；

传入 L（无效）

void ListInitite(LinkList L) {
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
}

传入引用

void ListInitite(LinkList &L) {
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
}

传入 L 的指针

void ListInitite(LinkList *L) {
    *L = (LinkList)malloc(sizeof(LNode));
    (*L)->next = NULL;
}

创建一个单链表

头插法

即将新元素插入到链表的第一个位置

void List_HeadInsert(LinkList &L) {
    for(int i = 1; i <= 10; i++) { //将 1 ~ 10 按头插法插入单链表
        LNode* p = (LNode*)malloc(sizeof(LNode));
        p->data = i;
        p->next = L->next;
        L->next = p;
    }
    //按照头插法的插入方式结果为倒序
    Show_List(L);
}

测试本段代码

#include<iostream>
#include<cstdlib>
using namespace std; 

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

void ListInitite(LinkList &L) {
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
}

void Show_List(LinkList L) {
    LNode* p = L->next;
    while (p)
    {
        printf("%d ", p->data);
        p = p->next;
    }
}

void List_HeadInsert(LinkList &L) {
    for(int i = 1; i <= 10; i++) { //将 1 ~ 10 按头插法插入单链表
        LNode* p = (LNode*)malloc(sizeof(LNode));
        p->data = i;
        p->next = L->next;
        L->next = p;
    }
    //按照头插法的插入方式结果为倒序
    Show_List(L);
}

int main() {
    LinkList L;
    ListInitite(L);
    List_HeadInsert(L);
    return 0;
}

运行结果

10 9 8 7 6 5 4 3 2 1

尾插法

即新的元素放在链表尾

使用尾插法，需要定义一个尾指针 r，尾指针始终指向链表的最后一个元素；刚开始为空链表，尾指针指向头节点，即和 L 相等，此后每插入一个新的结点，新的结点成为新的尾结点，r 指向此结点；

void List_TailInsert(LinkList &L) {
    LNode* r = L;
    for(int i = 1; i <= 10; i++) {
        LNode* p = (LNode*)malloc(sizeof(LNode));
        p->data = i;
        p->next = r->next;
        r->next = p;
        r = p;
    }
}

测试：

#include<iostream>
#include<cstdlib>
using namespace std;

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

void ListInitite(LinkList &L) {
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
}

void Show_List(LinkList L) {
    LNode* p = L->next;
    while (p)
    {
        printf("%d ", p->data);
        p = p->next;
    }
}

void List_HeadInsert(LinkList &L) {
    for(int i = 1; i <= 10; i++) { //将 1 ~ 10 按头插法插入单链表
        LNode* p = (LNode*)malloc(sizeof(LNode));
        p->data = i;
        p->next = L->next;
        L->next = p;
    }
    //按照头插法的插入方式结果为倒序
    Show_List(L);
}

void List_TailInsert(LinkList &L) {
    LNode* r = L;
    for(int i = 1; i <= 10; i++) {
        LNode* p = (LNode*)malloc(sizeof(LNode));
        p->data = i;
        p->next = r->next;
        r->next = p;
        r = p;
    }
}

int main() {
    LinkList L;
    ListInitite(L);
    List_TailInsert(L);
    //按尾插法插入为顺序 
    Show_List(L);
    return 0;
}

测试结果：

1 2 3 4 5 6 7 8 9 10

返回链表的长度

int Length(LinkList L) {
    LNode* p = L;
    int length = 0;
    while (p->next) {
        length++;
        p = p->next;
    }
    return length;
}

链表的查询

按序号查找结点的值

即查找第 i 个结点的值，最终返回此结点

LNode* GetElem(LinkList L, int i) {
    if(i == 0) {
        return L;
    }
    if(i < 1 || i > Length(L)) {   //若超出链表范围
        return NULL;
    }
    LNode* p = L;
    int now = 0;
    while(p && now < i) {
        p = p->next;
        now++;
    }
    return p;
}

测试：

#include<iostream>
#include<cstdlib>
using namespace std;

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

void ListInitite(LinkList &L) {
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
}

void Show_List(LinkList L) {
    LNode* p = L->next;
    while (p)
    {
        printf("%d ", p->data);
        p = p->next;
    }
}

void List_TailInsert(LinkList &L) {
    LNode* r = L;
    for(int i = 1; i <= 10; i++) {
        LNode* p = (LNode*)malloc(sizeof(LNode));
        p->data = i;
        p->next = r->next;
        r->next = p;
        r = p;
    }
}

int Length(LinkList L) {
    LNode* p = L;
    int length = 0;
    while (p->next) {
        length++;
        p = p->next;
    }
    return length;
}


LNode* GetElem(LinkList L, int i) {
    if(i == 0) {
        return L;
    }
    if(i < 1 || i > Length(L)) {   //若超出链表范围
        return NULL;
    }
    LNode* p = L;
    int now = 0;
    while(p && now < i) {
        p = p->next;
        now++;
    }
    return p;
}


int main() {
    LinkList L;
    ListInitite(L);
    List_TailInsert(L);
    LNode* ip = GetElem(L, 5);
    Show_List(L);
    if(ip) {
        printf("\n%d", ip->data);
    }
    return 0;
}

测试结果：

1 2 3 4 5 6 7 8 9 10
5

按值查找结点

LNode* LocateElem(LinkList L, ElemType e) {
    LNode* p = L->next;
    while(p && p->data != e) {
        p = p->next;
    }
    return p;
}

插入结点

在链表的第 i 个位置插入元素 e

插入新的元素后共有 len + 1 个元素，插入位置也必须在 [1, len + 1]，因此插入位置必须在这个范围内；首先获得第 i - 1 个结点，然后进行操作；

bool ListInsert(LinkList &L, int i, ElemType e) {
    if(i < 1 || i > Length(L) + 1) {
        printf("插入位置错误\n");
        return false;
    }
    LNode *pre, *s;
    s->data = e;
    pre = GetElem(L, i - 1);
    s->next = pre->next;
    pre->next = s;
    return true;
}

测试代码：

#include<iostream>
#include<cstdlib>
using namespace std;

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

void ListInitite(LinkList &L) {
	L = (LinkList)malloc(sizeof(LNode));
	L->next = NULL;
}

void Show_List(LinkList L) {
	LNode* p = L->next;
	while (p) {
		printf("%d ", p->data);
		p = p->next;
	}
}

void List_HeadInsert(LinkList &L) {
	for(int i = 1; i <= 10; i++) { //将 1 ~ 10 按头插法插入单链表
		LNode* p = (LNode*)malloc(sizeof(LNode));
		p->data = i;
		p->next = L->next;
		L->next = p;
	}
}


int Length(LinkList L) {
	LNode* p = L->next;
	int length = 0;
	while(p) {
		length++;
		p = p->next;
	}
	return length;
}


LNode* GetElem(LinkList L, int i) {
	if(i == 0) {
		return L;
	}
	if(i < 1 || i > Length(L)) {   //若超出链表范围
		return NULL;
	}
	LNode* p = L;
	int now = 0;
	while(p && now < i) {
		p = p->next;
		now++;
	}
	return p;
}


bool ListInsert(LinkList &L, int i, ElemType e) {
    if(i < 1 || i > Length(L) + 1) {
        printf("插入位置错误\n");
        return false;
    }
    LNode *pre = GetElem(L, i - 1);
    LNode *s = (LNode*)malloc(sizeof(LNode));
    s->data = e;
    s->next = pre->next;
    pre->next = s;
    return true;
}

int main() {
	LinkList L;
	ListInitite(L);
	List_HeadInsert(L);
	ListInsert(L, 5, 100);
	Show_List(L);
	return 0;
}

测试结果：

10 9 8 7 100 6 5 4 3 2 1

前插和后插

前插即在一个已知结点的前面插入新的结点，后插即在一个已知结点的后面插入新的结点；

上面的插入函数即在结点的后面插入新的结点，首先需要得到第 i - 1 个结点，然后再此结点后面插入新的结点，即为后插；

前插操作也是类似，在某个结点的前面插入结点，首先获取到此结点的前一个结点，然后在前一个结点后面插入新的结点；但这种插入方式必须首先获取到已知结点的前一个结点，查找过程必须遍历当前结点之前的所有元素才能找到前一个结点；时间复杂度为 O(n)，采用另一种方式可以巧妙的将复杂度降低到 O(1)；方法为在已知结点的后面插入新的结点，然后交换新节点与已知结点的值，就实现了相同的目的；

void FrontInsert(LNode* node, ElemType e) {
    LNode *s = (LNode*)malloc(sizeof(LNode));
    s->data = e;
    s->next = node->next;
    node->next = s;
    ElemType temp = node->data;
    node->data = s->data;
    s->data = temp;
}

2~5 行操作为将新的结点插入到已知结点的后面，6~8 行操作为交换两个结点内的值；

测试：

#include<iostream>
#include<cstdlib>
using namespace std;

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

void ListInitite(LinkList &L) {
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
}

void Show_List(LinkList L) {
    LNode* p = L->next;
    while (p)
    {
        printf("%d ", p->data);
        p = p->next;
    }
}

void List_HeadInsert(LinkList &L) {
    for(int i = 1; i <= 10; i++) { //将 1 ~ 10 按头插法插入单链表
        LNode* p = (LNode*)malloc(sizeof(LNode));
        p->data = i;
        p->next = L->next;
        L->next = p;
    }
}


int Length(LinkList L) {
    LNode* p = L->next;
    int length = 0;
    while(p) {
        length++;
        p = p->next;
    }
    return length;
}


LNode* GetElem(LinkList L, int i) {
    if(i == 0) {
        return L;
    }
    if(i < 1 || i > Length(L)) {   //若超出链表范围
        return NULL;
    }
    LNode *p = L;
    int now = 0;
    while(p && now < i) {
        p = p->next;
        now++;
    }
    return p;
}


void FrontInsert(LNode* &node, ElemType e) {
    LNode *s = (LNode*)malloc(sizeof(LNode));
    s->data = e;
    s->next = node->next;
    node->next = s;
    ElemType temp = node->data;
    node->data = s->data;
    s->data = temp;
}


int main() {
    LinkList L;
    ListInitite(L);
    List_HeadInsert(L);
    Show_List(L);
    LNode *node = GetElem(L, 5);
    FrontInsert(node, 50);
    printf("\n");
    Show_List(L);
    return 0;
}

测试结果：

10 9 8 7 6 5 4 3 2 1
10 9 8 7 50 6 5 4 3 2 1

删除结点操作

删除链表位置为 i 的结点，并将删除的结点存放在 node 中

bool ListDelete(LinkList &L, int i, LNode* &node) {
    if(i < 1 || i > Length(L)) {
        printf("删除位置错误");
        return false;
    }
    LNode *p = GetElem(L, i - 1);
    LNode *q = p->next;
    p->next = q->next;
    node = q;
    free(q);
    return true;
}

上述代码有错，free(void* p) 函数的作用是回收 动态分配给 p 的空间，不论有多少指针指向 p 所指向的空间，因此将对于 node = q，在 free(q) 以后 node 所指向的空间也被回收了，因此此处最好不返回结点，返回结点中的值；修正后的代码如下：

bool ListDelete(LinkList &L, int i, ElemType &del) {
    if(i < 1 || i > Length(L)) {
        printf("删除位置错误");
        return false;
    }
    LNode *p = GetElem(L, i - 1);
    LNode *q = p->next;
    p->next = q->next;
    del = q->data;
    free(q);
    return true;
}

测试：

#include<iostream>
#include<cstdlib>
using namespace std;

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

void ListInitite(LinkList &L) {
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
}

void Show_List(LinkList L) {
    LNode* p = L->next;
    while (p)
    {
        printf("%d ", p->data);
        p = p->next;
    }
}

void List_TailInsert(LinkList &L) {
    LNode* r = L;
    for(int i = 1; i <= 10; i++) {
        LNode* p = (LNode*)malloc(sizeof(LNode));
        p->data = i;
        p->next = r->next;
        r->next = p;
        r = p;
    }
}

int Length(LinkList L) {
    LNode* p = L->next;
    int length = 0;
    while(p) {
        length++;
        p = p->next;
    }
    return length;
}


LNode* GetElem(LinkList L, int i) {
    if(i == 0) {
        return L;
    }
    if(i < 1 || i > Length(L)) {   //若超出链表范围
        return NULL;
    }
    LNode *p = L;
    int now = 0;
    while(p && now < i) {
        p = p->next;
        now++;
    }
    return p;
}


bool ListDelete(LinkList &L, int i, ElemType &del) {
    if(i < 1 || i > Length(L)) {
        printf("删除位置错误");
        return false;
    }
    LNode *p = GetElem(L, i - 1);
    LNode *q = p->next;
    p->next = q->next;
    del = q->data;
    free(q);
    return true;
}

int main() {
    LinkList L;
    ListInitite(L);
    List_TailInsert(L);
    Show_List(L);
    ElemType del;
    ListDelete(L, 7, del);
    printf("\n");
    Show_List(L);
    printf("\n删除的元素为：%d", del);
    return 0;
}

结果：

1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 8 9 10
删除的元素为：7

此处删除的实现依然为后删，即找到将要删除结点的前一个结点进行删除；即给定一个已知结点需要对其进行删除，首先应该找到其前驱节点才能进行删除；和前插法类似，也有减少其复杂度的方法，即首先交换待删除结点后其后继节点的值，然后删除其后继节点；实现方式和前插法类似：

void Del(LinkList &L, LNode* &p) {
    LNode* q = p->next;
    ElemType temp = q->data;
    q->data = p->data;
    p->data = temp;
    p->next = q->next;
    free(q);
}

当然此时对于极端情况，即要删除的元素为最后一个元素时不适用；

测试：

#include<iostream>
#include<cstdlib>
using namespace std;

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

void ListInitite(LinkList &L) {
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
}

void Show_List(LinkList L) {
    LNode* p = L->next;
    while (p)
    {
        printf("%d ", p->data);
        p = p->next;
    }
}

void List_TailInsert(LinkList &L) {
    LNode* r = L;
    for(int i = 1; i <= 10; i++) {
        LNode* p = (LNode*)malloc(sizeof(LNode));
        p->data = i;
        p->next = r->next;
        r->next = p;
        r = p;
    }
}

int Length(LinkList L) {
    LNode* p = L->next;
    int length = 0;
    while(p) {
        length++;
        p = p->next;
    }
    return length;
}


LNode* GetElem(LinkList L, int i) {
    if(i == 0) {
        return L;
    }
    if(i < 1 || i > Length(L)) {   //若超出链表范围
        return NULL;
    }
    LNode *p = L;
    int now = 0;
    while(p && now < i) {
        p = p->next;
        now++;
    }
    return p;
}



void Del(LinkList &L, LNode* &p) {
    LNode* q = p->next;
    ElemType temp = q->data;
    q->data = p->data;
    p->data = temp;
    p->next = q->next;
    free(q);
}

int main() {
    LinkList L;
    ListInitite(L);
    List_TailInsert(L);
    Show_List(L);
	LNode *p = GetElem(L, 4);
	Del(L, p);
	printf("\n");
	Show_List(L);
    return 0;
}

结果：

1 2 3 4 5 6 7 8 9 10
1 2 3 5 6 7 8 9 10

单链表的销毁

void Destory(LinkList &L) {
    LNode* p = L;
    LNode* q = L;
    while (q)
    {
        p = q;
        q = q->next;
        free(p);
    }
    free(L);  
    L=NULL;
}
数据结构单链表的基本操作及实现(C/C++)
06-03
数据结构单链表的基本操作及实现(C/C++)，包括初始化、创建链表、插入元素、删除元素、获取指定位置的元素等
数据结构单链表的实现（C++）
06-07
总结，通过C++实现单链表，我们需要理解节点结构、链表类的设计以及相关的操作（插入、删除、遍历）。在实际应用中，单链表常常用于实现动态数据结构，例如队列和栈，或者作为其他复杂数据结构的基础。理解并熟练...
C/C++实现单向循环链表(尾指针，带头尾节点)
weixin_34217773的博客
02-25 1135
　　C语言实现单向循环链表，主要功能为空链表创建，链表初始化（头插法，尾插法），链表元素读取，按位置插入，（有序链表）按值插入，按位置删除，按值删除，清空链表，销毁链表。 　　单向循环链表和单向链表的区别：（1）单向链表为头指针，循环链表为尾指针，头指针指向头结点，尾指针指向终端结点；（2）为统一方便操作，单向链表设置头结点，单向循环链表设置头结点和尾结点；（3）设置尾结点后，尾指针指向尾结点，...
关于c++单链表的取值，查找，插入，删除的代码细节问题
最新发布
tqsdyy_s2023e_fr的博客
10-10 738
为了帮初学单链表的同学更加深刻了解学习，以及理清思路
单链表的实现（C++）
说文科技，做有态度的研究。
03-01 771
使用C++实现单链表。其实我个人是推荐使用python的，C++版的单链表写着是真费劲儿，奈何已经上了贼船~
数据结构之单链表（C++实现）
complety的专栏
04-08 9108
很早前就想用C++来实现那些常用的数据结构。 今天就算是个开端把。还是那句话，看的再多不如自己动手写一遍。 按照自己的思路写。首先你得熟悉那种结构的特点，然后才能谈实现。  链表是一种很常用的数据结构。支持在任意地方对数据进行增删改查。 但是不支持随机访问。所以复杂度就有些高了。写的时候出了个问题。 最后把内存查看了几遍。并不是保存数据的结点出问题了。而是在链表转置 的时候用到的那个i
数据结构单链表C++实现
weixin_46396711的博客
06-08 700
单链表简单介绍 单链表是线性表的一种，其逻辑结构为线性结构，采用链式存储结构，不同于顺序表既能顺序存取又可随机存取，单链表只能顺序存取。优点是添加和删除元素方便，时间复杂度为O(1)，缺点是查找元素比较麻烦，需从头指针开始遍历，时间复杂度为O(n)。 单链表数据结构 typedef struct pe{ string name; string sex; int age; bool operator ==(const pe &p)//重载==运算符 { return(p.name==name&amp
单链表-C++数据结构之单链表实现.zip
03-13
4. **C++实现单链表**： 一个简单的单链表实现可能包括以下函数：构造函数、析构函数、插入节点、删除节点、查找节点和打印链表。例如： ```cpp class LinkedList { private: ListNode* head; public: ...
数据结构 单链表的实现及其应用
04-20
数据结构课程，是关于单链表的实现及其应用程序，希望可以帮助你
数据结构C++ 单链表的实现 .cpp和.h文件
01-21
本篇将深入探讨如何使用C++实现单链表，包括链表的建立、遍历、查找和删除操作。 首先，`LinkList.cpp`文件通常包含单链表类的实现，可能包括构造函数、插入节点、遍历链表、查找特定节点和删除节点等方法。`...
C++数据结构单链表实验：学生信息管理系统，源代码+实验报告.zip
11-14
对学生信息的单链表已经实现以下操作： //初始化 Status InitList(LinkList& L);...包含实验目的，实验分析，实验源程序，实验结果，适合数据结构中单链表的作业提交和学习，注释较多，适合基础人群学习。
单链表的C++实现
03-16
单链表的学习以及用C++语言实现，单链表逆置函数的实现
单链表的C++实现。。
08-23
数据结构上机实验课题之一，要求实现单链表的插入排序等功能。
数据结构——单链表的C++实现
zxr916的博客
11-02 458
数据结构——单链表的C++实现 \qquad单链表的创建、求长度、查找、插入和删除的C++实现。 #include<iostream> using namespace std; //1.定义 struct Node { int num; Node* next; }; typedef Node* List; void input(int* a) { cin >> *a; } //2.创建链表 void CreateList(List* L, int n, void (*inp
关于数据结构之单链表的C++实现
qq_43435984的博客
11-17 137
1、链表List的基本单元是节点Node，因此想要操作方便，就必须为每一步打好基础，Node的基本结构如下： class Node { public: int data; Node *next; Node(int da=0,Node *p=NULL) { this-&amp;amp;amp;amp;gt;data=da; this-&amp;amp;amp;amp;gt;next=p; } }; 我们可以看出，Node的成员变量一共有两个，都是public，因...
C++ 数据结构 单链表
qq_47168663的博客
09-22 422
C++，数据结构，单链表，线性表
C++数据结构--单链表
海到无边天作岸 山登绝顶我为峰
04-08 1236
题目         实现单链表的创建（分头部插入、尾部插入）、链表元素查找、删除、插入、输出各个元素，最后实现链表的翻转。（例：原链表为1->2->3->4 要求结果输出：4->3->2->1） 测试代码（部分） void rel() { node<t> *p;...
C++实现数据结构单链表操作
"数据结构中单链表的程序实现" 在计算机科学中，数据结构是组织、管理和存储数据的方式，而单链表是一种基础且重要的数据结构。单链表由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。这个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值