链表

于 2024-09-16 15:17:44 发布
阅读量245 收藏
点赞数 8
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wujiale123456/article/details/142302997
版权

链表

单链表

线性表：

  1. 有限的序列
  2. 序列中的每个元素都有唯一的前驱和后继，除了开头和结尾两个节点

线性表的两种实现：

顺序表：分配一块 连续的内存 去存放这些元素，例如编程语言中的数组

链表： 内存是不连续 的，元素会各自被分配一块内存，内存和内存之间用指针进行相连

​image​

单链表操作：

  1. 增加

    1. 头插法​image​
    2. 尾插法image​

  2. 删除：只需要找到对应节点，将对应节点的前一个节点指向这个结点的后继，只操作1个指针

头节点image​

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

typedef struct Node
{
	//数据域
	int data;
	//指针域
	struct Node* next;
}Node;

//初始化链表头节点
Node* initList()
{
	Node* list = (Node*)malloc(sizeof(Node));
	// 检查内存分配是否成功
    if (list == NULL)
    {
        printf("内存分配失败\n");
        return NULL;
    }
	list -> data = 0;
	list -> next = NULL;
	return list;
}

//头插法
void headInsert(Node* list,int data)
{
	//创建一个新的节点并分配内存
	Node* node = (Node*)malloc(sizeof(Node));
    // 检查内存分配是否成功
    if (node == NULL)
    {
        printf("内存分配失败\n");
        return;
    }
 	//设置新节点的数据字段
	node -> data = data;
 	//将新节点的 next 字段指向当前链表的第一个节点
	node -> next = list -> next;
	//将链表的头节点的 next 字段指向新节点
	list -> next = node;
	//增加链表头节点的数据字段以表示链表长度
	list -> data ++;
}

//尾插法
void tailInsert(Node* list,int data)
{
	Node* head = list;
	//创建一个新的节点并分配内存
	Node* node = (Node*)malloc(sizeof(Node));
    // 检查内存分配是否成功
    if (node == NULL)
    {
        printf("内存分配失败\n");
        return;
    }
 	//设置新节点的数据字段
	node -> data = data;
	node -> next = NULL;
    //遍历链表找到最后一个节点
    while (list->next != NULL)
    {
        list = list->next;
    }
	//将最后一个节点的 next 字段指向新节点
	list -> next = node;
	//增加链表头节点的数据字段以表示链表长度
	head -> data ++；
}

//删除
void delete(Node* list, int data)
{
	//初始化两个指针pre和current，分别指向链表的头节点和第一个节点
	Node* pre = list;
	Node* current = list -> next;
	//遍历链表，查找数据字段等于data的节点
	while(current)
	{
		//如果找到匹配的节点，将前一个节点的next字段指向当前节点的next字段
		if(current -> data == data)
		{
			pre -> next = current -> next;
			//释放当前节点的内存
			free(current);
			//更新链表长度
			list->data--; 
			break;
		}
		pre = current;
        current = current -> next;
	}
}

//打印链表
void printList(Node* list)
{
	//将指针移动到链表的第一个节点（跳过头节点）
	list = list -> next;
	//遍历链表，直到list为NULL
	while(list)
	{
		printf("%d",list -> data);
		list = list -> next;
	}
}

int main()
{
	Node* list = initList();
	headInsert(list,1);
	headInsert(list,2);
	headInsert(list,3);
	headInsert(list,4);
	headInsert(list,5);
	tailInsert(list,6);
	printList(list);
	return 0;
}

单循环链表

​image​

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

typedef struct Node
{
	//数据域
	int data;
	//指针域
	struct Node* next;
}Node;

//初始化单循环链表
Node* initList()
{
	Node* L = (Node*)malloc(sizeof(Node));
	if (L == NULL)
    {
        printf("内存分配失败\n");
        return NULL;
    }
	L -> data = 0;
	L -> next = L; //指向自身，形成循环
	return L;
}

//头插法
void headInsert(Node* L,int data)
{
	Node* node = (Node*)malloc(sizeof(Node));
	if (node == NULL)
    {
        printf("内存分配失败\n");
        return;
    }
	node -> data = data;
	node -> next = L -> next;
	L -> next = node;
	L->data++;
}

// 尾插法
void tailInsert(Node* L, int data)
{
    Node* head = L;
    Node* node = (Node*)malloc(sizeof(Node));
    if (node == NULL)
    {
        printf("内存分配失败\n");
        return;
    }
    node->data = data;
    node->next = head; //新节点指向头节点，形成循环
    while (L->next != head)
    {
        L = L->next;
    }
    L->next = node;
    head->data++;
}

// 删除节点
void delete(Node* L, int data)
{
    Node* pre = L;
    Node* current = L->next;
    while (current != L)
    {
        if (current->data == data)
        {
            pre->next = current->next;
            free(current);
            L->data--;
            break;
        }
        pre = current;
        current = current->next;
    }
}

// 打印链表
void printList(Node* L)
{
    Node* start = L->next;
    while (start != L)
    {
        printf("%d ", start->data);
        start = start->next;
    }
    printf("\n");
}

int main()
{
    Node* list = initList();
    headInsert(list, 1);
    headInsert(list, 2);
    tailInsert(list, 3);
    tailInsert(list, 4);
    printList(list);
    delete(list, 3);
    printList(list);
    return 0;
}

双链表

​image​

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

typedef struct Node
{
    int data;
    struct Node* next;
    struct Node* prev;
} Node;

// 初始化双链表
Node* initList()
{
    Node* L = (Node*)malloc(sizeof(Node));
    if (L == NULL)
    {
        printf("内存分配失败\n");
        return NULL;
    }
    L->data = 0;
    L->next = NULL;
    L->prev = NULL;
    return L;
}

// 头插法
void headInsert(Node* L, int data)
{
    // 分配内存并检查是否成功
    Node* node = (Node*)malloc(sizeof(Node));
    if (node == NULL)
    {
        printf("内存分配失败\n");
        return;
    }
    // 设置新节点的数据字段
    node->data = data;
    // 设置新节点的 next 和 prev 字段
    node->next = L->next;
    node->prev = L;
    // 更新原链表第一个节点的 prev 字段
    if (L->next != NULL)
    {
        L->next->prev = node;
    }
    // 将头节点的 next 字段指向新节点
    L->next = node;
    // 更新链表长度
    L->data++;
}

// 尾插法
void tailInsert(Node* L, int data)
{
    // 保存头节点的指针
    Node* head = L;
    // 分配内存并检查是否成功
    Node* node = (Node*)malloc(sizeof(Node));
    if (node == NULL)
    {
        printf("内存分配失败\n");
        return;
    }
    // 设置新节点的数据字段
    node->data = data;
    // 设置新节点的 next 字段为 NULL
    node->next = NULL;
    // 遍历链表，找到最后一个节点
    while (L->next != NULL)
    {
        L = L->next;
    }
    // 将最后一个节点的 next 字段指向新节点
    L->next = node;
    // 设置新节点的 prev 字段指向最后一个节点
    node->prev = L;
    // 更新链表长度
    head->data++;
}

// 删除节点
void delete(Node* L, int data)
{
    // 初始化指针 current，指向链表的第一个节点
    Node* current = L->next;
    // 遍历链表，查找数据字段等于 data 的节点
    while (current != NULL)
    {
        // 如果找到匹配的节点
        if (current->data == data)
        {
            // 如果当前节点不是最后一个节点，更新下一个节点的 prev 字段
            if (current->next != NULL)
            {
                current->next->prev = current->prev;
            }
            // 更新前一个节点的 next 字段
            current->prev->next = current->next;
            // 释放当前节点的内存
            free(current);
            // 更新链表长度
            L->data--;
            // 退出循环
            break;
        }
        // 移动到下一个节点
        current = current->next;
    }
}


// 打印链表
void printList(Node* L)
{
    Node* start = L->next;
    while (start != NULL)
    {
        printf("%d ", start->data);
        start = start->next;
    }
    printf("\n");
}

int main()
{
    Node* list = initList();
    headInsert(list, 1);
    headInsert(list, 2);
    tailInsert(list, 3);
    tailInsert(list, 4);
    printList(list);
    delete(list, 3);
    printList(list);
    return 0;
}

双循环链表

​image​

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

typedef struct Node
{
    int data;
    struct Node* next;
    struct Node* prev;
} Node;

// 初始化双循环链表
Node* initList()
{
    // 分配内存并检查是否成功
    Node* L = (Node*)malloc(sizeof(Node));
    if (L == NULL)
    {
        printf("内存分配失败\n");
        return NULL;
    }
    // 初始化头节点
    L->data = 0;
    L->next = L; // 指向自身，形成循环
    L->prev = L; // 指向自身，形成循环
    return L;
}

// 头插法
void headInsert(Node* L, int data)
{
    // 分配内存并检查是否成功
    Node* node = (Node*)malloc(sizeof(Node));
    if (node == NULL)
    {
        printf("内存分配失败\n");
        return;
    }
    // 设置新节点的数据字段
    node->data = data;
    // 设置新节点的 next 和 prev 字段
    node->next = L->next;
    node->prev = L;
    // 更新原链表第一个节点的 prev 字段
    L->next->prev = node;
    // 将头节点的 next 字段指向新节点
    L->next = node;
    // 更新链表长度
    L->data++;
}

// 尾插法
void tailInsert(Node* L, int data)
{
    // 分配内存并检查是否成功
    Node* node = (Node*)malloc(sizeof(Node));
    if (node == NULL)
    {
        printf("内存分配失败\n");
        return;
    }
    // 设置新节点的数据字段
    node->data = data;
    // 设置新节点的 next 和 prev 字段
    node->next = L;
    node->prev = L->prev;
    // 更新原链表最后一个节点的 next 字段
    L->prev->next = node;
    // 将头节点的 prev 字段指向新节点
    L->prev = node;
    // 更新链表长度
    L->data++;
}

// 删除节点
void delete(Node* L, int data)
{
    // 初始化指针 current，指向链表的第一个节点
    Node* current = L->next;
    // 遍历链表，查找数据字段等于 data 的节点
    while (current != L)
    {
        // 如果找到匹配的节点
        if (current->data == data)
        {
            // 更新前一个节点的 next 字段
            current->prev->next = current->next;
            // 更新下一个节点的 prev 字段
            current->next->prev = current->prev;
            // 释放当前节点的内存
            free(current);
            // 更新链表长度
            L->data--;
            // 退出循环
            break;
        }
        // 移动到下一个节点
        current = current->next;
    }
}

// 打印链表
void printList(Node* L)
{
    // 初始化指针 start，指向链表的第一个节点
    Node* start = L->next;
    // 遍历链表，直到回到头节点
    while (start != L)
    {
        // 打印当前节点的数据字段
        printf("%d ", start->data);
        // 移动到下一个节点
        start = start->next;
    }
    // 打印换行符
    printf("\n");
}

int main()
{
    Node* list = initList();
    headInsert(list, 1);
    headInsert(list, 2);
    tailInsert(list, 3);
    tailInsert(list, 4);
    delete(list, 3);
    printList(list);
    return 0;
}
霜程
关注
静态链表
Minix的博客
03-27 2300
静态链表 静态链表（static linked list）是用数组来表示单链表，用数组元素的下标来模拟单链表的指针。这种描述方法称为游标（cursor）实现法。 静态链表，也是线性存储结构的一种，它兼顾了顺序表和链表的优点于一身，可以看做是顺序表和链表的升级版。 在链表的指针实现中有两个重要的特点： 数据存储在一组结构体中，每一个结构体包含有数据以及指向下一个结构体的指针； 一个新的结构体可以通过调用 malloc() 函数从系统全局内存得到，并可通过调用 free() 函数而被释放。 游标法必须能够模
07丨链表（下）：如何轻松写出正确的链表代码？1
08-03
【链表】是一种重要的数据结构，它不像数组那样在内存中连续存储，而是通过节点间的指针连接起来。链表的每个节点包含数据和指向下一个节点的指针，这种结构使得链表在插入和删除操作上相比数组更具优势，但同时也...
C语言链表超详解
k666499436的博客
05-17 12万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
链表基础知识详解（非常详细简单易懂）
qq_61672347的博客
07-10 17万+
数据结构链表详解，创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作，非常详细
C语言—链表
weixin_73588765的博客
01-01 1万+
【C语言】—链表 创建,遍历,增删改查 链表是一种数据结构，是一种数据存放的思想；
c语言链表详解（超详细）
热门推荐
Endeavor_G的博客
06-03 62万+
链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。说到这里你应该就明白...
Python链表
sikh_0529的博客
09-12 1万+
链表是一系列数据元素，通过链接连接在一起。 每个数据元素都以指针的形式包含到另一个数据元素的连接。 Python在其标准库中没有链接列表。 我们使用前一章讨论的节点概念来实现链表的概念。 我们已经知道如何创建节点类以及如何遍历节点的元素。 在本章中，将学习链表的类型:单链表。 在这种类型的数据结构中，任何两个数据元素之间只有一个链接。 创建一个链表并使用一些方法来插入，更新和从列表中移除元素。通过使用在上一章中学习的节点类来创建链表。创建一个对象并创建另一个类来使用这个节点对象。 通过节点对象传递适当的值来
链表逆置详细讲解（图文）
qq_51366188的博客
02-26 3万+
链表逆置   前言 链表逆置是初学时有困扰到我的难点. 由于链表头结点可放可不放数据，所以写代码时候**->next**用的云里雾里。 这里讲解头结点与第一结点区分的情况，即头结点你把它看作这个 链表的“文件名” 就行。 若头结点为L，则第一结点为L->next。   代码 void listReverse(linkedList &L) { node *p,*s; //1. p = L->next; L->next = NULL; while
C语言链表详解附实例
xiaoxiaodawei的博客
03-11 2万+
链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。链表和数组比较，不用事先确定存储空间，而是根据需要开辟内存单元。本文章实现了用C语言编写学生管理系统，可以实现添加、删除、增加..,等功能
Python 数据库——链表
思则变的专栏
09-12 3641
链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表在逻辑上是连续的，但是在物理空间上可能是不连续的，因为链表的内存都是临时申请的，不一定会申请到连续的内存空间。常用的链表有单向链表和双向链表。这里主要介绍单项链表。单项链表的组成节点有两部分构成：数据和下一个列表的存储地址。单节点结构图：链表结构图：可以看到每一个节点中的addr都指向下一个节点的地址，phead为整个链表的头节点，不能改变，否则就会找不到整个链表。
链表填空题（打印）1
08-08
【链表基础知识】 链表是一种线性数据结构，与数组不同，它不连续存储数据，而是通过节点间的指针连接。每个节点包含数据部分和一个指向下一个节点的指针。链表分为单向链表、双向链表和循环链表等类型。 1. **...
Python单向链表和双向链表原理与用法实例详解
09-20
链表是一种重要的数据结构，它不同于数组，不连续存储元素，而是通过节点之间的引用关系连接。在Python中，我们可以自定义链表结构来实现单向链表和双向链表。 单向链表（Single Linked List）的特点是每个节点只...
python算法题 链表反转详解
01-20
链表的反转是一个很常见、很基础的数据结构题，输入一个单向链表，输出逆序反转后的链表，如图：上面的链表转换成下面的链表。实现链表反转有两种方式，一种是循环迭代，另外一种方式是递归。 第一种方式：循坏...
21_动态规划与数据结构结合
刘炫320的博客
09-11 569
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
数据结构 Java DS——分享部分链表题目 (2)
cjejwe的博客
09-10 971
关于JAVA的链表,笔者已经写了两篇博客来介绍了,今天给笔者们带来第三篇,也是分享了一些笔者写过的,觉得挺好的题目,链接也已经挂上了,笔者们可以去看看。
浙大数据结构：05-树7 堆中的路径
qq_74924951的博客
09-11 688
int size;}* Heap;int size;} *Heap;return H;int i;for (;for (;x;i < n;int f = 0;i < l;f = 1;return 0;
数据结构之红黑树的 “奥秘“
robin_suli的博客
09-09 1092
红黑树在经常进行增删的结构中性能比 AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。红黑树不追求绝对平衡，其只需保 证最长路径不超过最短路径的2倍(相对平衡)每个结点上增加一个存储位表示结点的颜色。红黑树和AVL树都是高效的平衡二叉树。没有一条路径会比其他路径长出俩倍。先grandParent右旋。围绕红黑树上面的几条性质。
数据结构 - 栈
最新发布
kaneki_lh的博客
09-13 494
/指向栈的指针int maxlen;//表示栈的最大长度int top;//栈顶元素的下标，用来指明栈顶的位置}s//数据域名//指针，指向栈下一个元素。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值