链表de小记

最新推荐文章于 2024-07-24 23:21:08 发布
最新推荐文章于 2024-07-24 23:21:08 发布
阅读量768 收藏 18
点赞数 25
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80073794/article/details/134920832
版权

认识链表：

什么是链表：

链表（Linked list）是一种常见的基础数据结构，是一种线性表。它不像顺序表一样连续存储数据，而是在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址，链表可以看成一条项链，节点就是其中一环。一环一环套起来，就形成了项链（链表）。

链表的特点：

  1. 链表可以没有表示整体的对象，只需要用节点就够了。表示一整条链表可以用“头节点”，也就是第一个节点来表示整条链。

  2. 总是可以用一个节点的next指针走到下一个节点。而且大部分情况下只有这一种方法——链表没有下标，也不能直接跳转到某一环。只能从一个节点出发，一步一步往后挪。

  3. 链表的删除操作很快，与链表长度无关。

  4. 链表的插入也很快，与链表长度无关。

  5. 链表的查找需要从头遍历，与数组类似，越长速度越慢。

链表与数组的区别：

数组：连续性，方便快速定位，但不方便插入等操作；

链表：非连续，方便插入等操作，即使删除某一个节点，只需要将前一个的指针指向下一个，但是损失了查找效率和空间。

什么是链表：

拿到第一个节点，就等于拿到了全部。建议增加头结点，不存储任何数据，避免插入第一个的情况。

链表的分类：

静态与动态；

单向与双向；

有没有头节点；

循环，单向循环与双向循环。

.............

二个静态链表的实例：

1.

#include <stdio.h>
 struct linknode {
    int data;
    struct linknode *next;
    //struct linknode *next;中的next是结构体类型的原因：
    //在链表中，每个节点都需要一个指针指向下一个节点。因此，我们需要一个与节点相同类型的指针，即struct linknode *next;
    //这样，我们就可以通过next指针访问链表中的下一个节点。
};
void test() {
struct  linknode node1= { 19,NULL};
struct  linknode node2 = { 9,NULL };
struct  linknode node3 = { 8,NULL };
struct  linknode node4 = { 68,NULL };
struct  linknode node5 = { 1,NULL };
struct  linknode node6 = { 39,NULL };
node1.next = &node2;
node2.next = &node3;
node3.next = &node4;
node4.next = &node5;
node5.next = &node6;
struct linknode* p = &node1**;//对于一个结构体，我们可以定义结构体中某一个变量的类型的指针，而不一定要包含其中所有的变量，
//例如struct linknode* p = &node1;它只是定义了一个结构体指针，而没有定义其中的data；
//但是这个指针p可以访问它所指向的结构体node1中的所有变量，包括data和next。
while (p != NULL) {
printf("%d", p->date);
    p = p->next;
}
}
int main() {
​
    test();
    return 0;
​
}
代码使用的是指针而不是游标来链接节点，但是它仍然可以被认为是静态链表。静态链表可以使用指针或数组索引来表示下一个节点的位置信息，而游标只是其中一种常见的表示方式。

在这段代码中，使用指针来链接节点，每个节点包含一个指向下一个节点的指针。这种实现方式与单链表类似，但是它仍然属于静态链表的范畴。

静态链表和单链表的主要区别在于它们的数据存储方式和访问方式。单链表为每个节点分配独立的内存空间，而静态链表则将数据元素和游标存储在同一个数组中。在静态链表中，每个元素包含两个部分：数据和游标（或指针），游标指示下一个元素在数组中的位置。这种数据存储方式使得静态链表的空间利用率更高，但它们的访问速度可能会比单链表慢一些。

总之，虽然没有明确使用游标，但它仍然属于静态链表的范畴。

然而这种写法实用性并不高，而且十分麻烦，只是手动连接。但是可以从中间看出，一个链表应该包含什么和一些基本的用法：

1.结构体的创建：

struct linknode {
    int data;
    struct linknode *next;}

包含数据和索引(不一定为指针，也可以为游标）。

2.用索引来遍历输出。

例如：struct linknode* p = &node1;

我们也可以创建一个带头结点的链表：

创建空链表：
struct linknode {
    int date;
    struct linknode* next;
};
struct linknode* create(void) {//创建带头结点的链表
    struct linknode* list = (struct linknode*)malloc(sizeof(struct linknode));//向堆空间申请内存，不然会自动释放，如果在函数中不进行malloc内存分配，那么是在栈空间中分配，会自动释放。
//这行代码的意思是在堆内存中为一个 linknode 结构体分配空间，并将这块空间的地址赋值给 list 指针。让我们来详细解释一下：
 // malloc(sizeof(struct linknode)) 的作用就是在堆内存中分配一块大小等于一个 linknode 结构体的空间。   
    //(struct linknode*)强制转换：因为 malloc 返回的是一个 void* 类型的指针（也就是通用指针）， 所以我们需要将其转换为 struct linknode* 类型，这样才能将其赋值给 list。
if (list == NULL) {//判断是否分配成功
    return NULL;}
else
    list->next = NULL;
//list 是一个指向 linknode 结构体的指针。当你创建一个新的 linknode 结构体并将其地址赋值给 list 时，
//你可以通过 list 访问和修改该结构体的成员。在你的代码中，list->next = NULL; 这行代码是将 next 成员设置为 NULL
return list;
}
// 这是链表的常见初始化步骤，表示链表当前没有其他节点。
创建其他结点：
{
    struct linknode* p = list;
    for (int i = 0; i < n; i++) {
        struct linknode* temp = (struct linknode*)malloc(sizeof(struct linknode));
        temp->data = data[i];
        //链接
        p->next = temp;
        //p后移
        p = p->next;
    }
p->next = NULL;
    return list;
}

每次都需要分配内存，并且输入数据。

struct linknode* p = list;，p用来连接各个节点，并把最后一个节点指针域置空。

输出链表：
void show_list(struct linknode* list) {
    if (list == NULL)
        return;
    else
    {
        for (struct linknode* p = list->next; p; p = p->next) {
            printf("%d ", p->data);
        }
    }
}

注意：

struct linknode* p = list->next；如果写成struct linknode* p = list，将会打印出头结点的数据，但没有进行初始化，会是垃圾值。

链表的结点删除：
 void list_del(struct linknode* list,int  data) {
    struct linknode* p = list;
    for (p; p->next; p = p->next) {//注意遍历到倒数第二个停止
        if (p->next->data == data) {
            struct linknode* del = p->next;
            p->next = del->next;
            free(del);//释放内存，更加安全。
        }
    }
​
}
链表的插入：
void list_insert(struct linknode *list,int data,int position) {
    struct linknode* p = list;
    if (p->next == NULL) {
        struct linknode* new = (struct linknode*)malloc(sizeof(struct linknode));
        new->data = data;
        return;
    }
    else
    {   
        for (p; p; p = p->next) {
               position--;
            if (position == 1) {
                break;
            }
        }
    struct linknode* new = (struct linknode*)malloc(sizeof(struct linknode));
    new->data = data;
    new->next = p->next->next;
    p->next = new;
    }
    return;}
单向循环：
struct linknode *last=(struct linknode*)malloc(sizeof(struct linknode));

last->next=head;
完整的一个带头结点的单链表（数组创建）：
#include <stdio.h>
#include <stdlib.h>
struct linknode {
	int data;
	struct linknode* next;
};
struct linknode* list_create(int data[], int n) {
	struct linknode* list = (struct linknode*)malloc(sizeof(struct linknode));
	if (list == NULL) {
		return NULL;
	}
	else
	{
		struct linknode* p = list;
		for (int i = 0; i < n; i++) {
			struct linknode* temp = (struct linknode*)malloc(sizeof(struct linknode));
			temp->data = data[i];
			//链接
			p->next = temp;
			//p后移
			p = p->next;
		}
	p->next = NULL;
		return list;
	}
}
void show_list(struct linknode* list) {
	if (list == NULL)
		return;
	else
	{
		for (struct linknode* p = list->next; p; p = p->next) {
			printf("%d ", p->data);
		}
	}
}

int main() {

int data[10] = { 1,2,3,4,5,6,7,8,9,0 };
struct linknode* list = list_create(data, 10);
if(list!=NULL){
show_list(list);
}
return 0;}
完整的一个手动输入创建的单链表（带头结点）：
#include <stdio.h>
#include <stdlib.h>
struct Node {
  int data;
  struct Node* next;
};
int main() {
  int n, i, data;
  struct Node* head, * new_node, * temp;
  printf("Enter the number of nodes: ");
  scanf("%d", &n);
  // 创建第一个节点
  head = (struct Node*)malloc(sizeof(struct Node));
  if (!head) {
    printf("Memory allocation failed.");
    return 0;
  }
  printf("Enter the data for node 1: ";
  scanf("%d", &data);
  head->data = data;
  head->next = NULL;
  temp = head;
  // 创建剩余节点
  for (i = 2; i <= n; ++i) {
    new_node = (struct Node*)malloc(sizeof(struct Node));
    if (!new_node) {
      printf("Memory allocation failed.");
      return 0;
    }
    printf("Enter the data for node %d: ", i);
    scanf("%d", &data);
    new_node->data = data;
    new_node->next = NULL;
    temp->next = new_node;
    temp = new_node;
  }
  // 输出链表中的数据元素
  printf("\nCreated Linked List is: ");
  temp = head;
  while (temp != NULL) {
    printf("%d ", temp->data);
    temp = temp->next;
  }
  printf("\n");
  // 释放内存
  temp = head;
  while (temp != NULL) {
    head = temp->next;
    free(temp);
    temp = head;
  }
  return 0;
}

双链表：

与单链表相比，多了一个指针域，指向前面的链表。
一个基础的双链表，包含头结点，插入，删除和输出，其实例如下：
#include <stdio.h>
#include <stdlib.h>

struct node {
	int data;
	struct node* pre;
	struct node* next;
};

struct node* init(void) {
	struct node* head = (struct node*)malloc(sizeof(struct node));
	head->next = NULL;
	head->pre = NULL;
	head->data = 0;
	return head;
}

void add_new(int k, struct node* head) {
	struct node* new = (struct node*)malloc(sizeof(struct node));
	new->data = k;
	new->pre = head;
	new->next = head->next;
	head->next = new;
}

void delete_node(int k, struct node* head) {
	struct node* temp = head->next;
	while (temp != NULL) {
		if (temp->data == k) {
			temp->pre->next = temp->next;
			if (temp->next != NULL) {
				temp->next->pre = temp->pre;
			}
			free(temp);
			return;
		}
		temp = temp->next;
	}
}

void print_list(struct node* head) {
	struct node* temp = head->next;
	while (temp != NULL) {
		printf("%d ", temp->data);
		temp = temp->next;
	}
	printf("\n");
}

int main() {
	struct node* head = init();
	int n, k, d;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &k);
		add_new(k, head);
	}
	scanf("%d", &d);
	delete_node(d, head);
	print_list(head);
	return 0;
}
上面用的头插法，我们也可以用尾插法在链表尾部插入一个元素，例如：
void add_new(int k, struct node* head) {
	struct node* new = (struct node*)malloc(sizeof(struct node));
	new->data = k;
	new->next = NULL;
	struct node* temp = head;
	while (temp->next != NULL) {
		temp = temp->next;
	}
	new->pre = temp;
	temp->next = new;
}
当然，也可以在任意位置进行添加，原理也大差不差：
void add_new(int k, int position, struct node* head) {
	struct node* new = (struct node*)malloc(sizeof(struct node));
	new->data = k;
	struct node* temp = head;
	int i = 0;
	while (temp != NULL && i < position) {
		temp = temp->next;
		i++;
	}
	if (temp != NULL) {
		new->next = temp->next;
		new->pre = temp;
		if (temp->next != NULL) {
			temp->next->pre = new;
		}
		temp->next = new;
	}
}
以上就是这周的一点很基础的小分享，第一次做，还是有点不习惯，请见谅。
Xiao Ling.
关注
  • 25
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
链表小结
小道名宇
08-05 346
单链表 也就是线性表的链式存储，它是指通过一组任意的存储单元来存储线性表中的数据元素，每个链表结点包含存放数据元素的数据域（data域）和存放后继结点的指针域 单结点的结点类型描述 typedef struct LNode { Elemtype data; struct LNode *next; }LNode,*Linklist; //或 typedef struct LNode { i...
链表中的笔记
洋葱专栏-有灵魂的程序员
08-14 316
ListLength(L) #define MAX 100 typedef struct{                               int *base;                                                         }
【Java数据结构】链表OJ提交小记
小S的博客
04-12 661
Java语言对力扣、牛客网上的一些链表的经典题目进行了分析总结，包含详细的解答分析和解答步骤图！
利用Volatility进行Windows内存取证分析(二)：内核对象、内核池学习小记
Fly_鹏程万里
05-16 4536
简介windows下内存取证的内容概括起来讲就是检测系统中有没有恶意程序,有没有隐藏进程,有没有隐藏文件,有没有隐藏服务,有没有隐藏的驱动,有没有隐藏网络端口等等.而进程,文件,驱动等等部件在内存中是以内核对象的形式独立存在的。而通常形形色色的rootkit会尝试修改操作系统的内部数据结构来达到隐藏自身的目的.安全研究员要想在内存取证中做到游刃有余,就需要对windows各种内存对象相关概念进行深...
C语言实现静态链表
08-18
C语言实现静态链表 C语言实现静态链表是指在C语言中使用静态数组来实现链表结构的方法。静态链表是一种特殊的链表结构，它的内存是事先分配好的，链表的每个结点都是一个固定长度的结构体，而不是像动态链表那样...
单向循环链表
01-20
循环链表 循环链表是一种特殊的单链表。实际上，循环链表也很简单。它跟单链表唯一的区别就在尾结点。我们知道，单链表的尾结点指针指向空地址，表示这就是最后的结点了。而循环链表的尾结点指针是指向链表的头结点...
链表分割1
08-03
链表分割1 链表分割是链表操作中的一种重要技巧，它可以将链表中的节点按照某种规则进行分割。给定一个链表的头指针和一个值x，编写代码将所有小于x的节点排在其余节点之前，且不能改变原来的数据顺序，返回重新...
重排链表1
08-03
题目 "重排链表1" 是一个典型的链表操作问题，来源于编程面试平台 LeetCode，主要考察的是链表处理和算法设计能力。该题目要求我们将一个单链表重新排列，使得原链表 `L0 → L1 → … → Ln-1 → Ln` 变为 `L0 → Ln...
基本链表1
08-08
在本文中，我们将深入探讨与链表相关的C#编程概念，虽然给定的代码是用C语言编写的，但链表的基本原理在C#中同样适用。链表是一种数据结构，它由一系列节点组成，每个节点包含数据以及指向下一个节点的指针。在这里...
c语言（7.23）
fhgfyrsg的博客
07-23 582
【代码】c语言（7.23）
【算法与数据结构】并查集
2301_79728896的博客
07-23 339
合并和查询集合的数据结构，KruskalLCA查询的时间复杂度：小于O(log2​n)近乎O(1)
Linux嵌入式学习——数据结构——线性表的链式结构
m0_71703182的博客
07-24 758
在链表的尾部插入一个新节点，该节点包含指定的数据data。函数返回成功或失败的状态码。
手撕数据结构02--二分搜索（附源码）
weixin_64593595的博客
07-24 343
对于二分搜索的理论与实现的知识点学习。
数据结构：逻辑结构与物理结构
最新发布
Weiki的博客
07-24 957
数据结构：逻辑结构与物理结构
数据结构之深入理解简单选择排序：原理、实现与示例（C，C++）
qq_35320456的博客
07-24 790
简单选择排序虽然在大数据量下效率不高，但它易于理解和实现，是理解排序算法基本思想的良好起点。在实际应用中，如果数据量较小或者对排序稳定性要求不高，选择排序可以作为一种简单有效的选择。
【初阶数据结构】复杂度算法题篇
2301_79849925的博客
07-24 320
我们可以先将所有元素翻转，这样尾部的 kmodn 个元素就被移至数组头部，然后我们再翻转 [0,kmodn−1] 区间的元素和 [kmodn,n−1] 区间的元素即能得到最后的答案。该方法基于如下的事实：当我们将数组的元素向右移动 k 次后，尾部 kmodn 个元素会移动至数组头部，其余元素向后移动 kmodn 个位置。时间复杂度：O(n)空间复杂度：O(1)
数据结构之判断完全二叉树详解与示例（C，C++）
qq_35320456的博客
07-23 434
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
算法 - 查找算法（顺序、折半、红黑树、AVL树、B+树、散列）
暴力扬
07-21 957
本文一共讲解了以下查找算法： 1. 顺序查找 2. 折半查找（二分查找） 3. 分块查找 4. 二叉排序树查找 5. 平衡二叉树（AVL树）查找 6. 红黑树查找 7. B树查找 8. B+树查找 9. 散列查找 每种查找算法都包括了其查找原理、实现步骤、代码实现思路、C语言代码以及代码解释。
C语言实现链表操作
"链表-C语言" 链表是一种在计算机科学中广泛使用的数据结构，尤其在C语言中，它的实现是编程基础的重要组成部分。链表不同于数组，它不连续存储数据，而是通过节点间的指针链接来表示逻辑顺序。每个节点包含两部分...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Xiao Ling.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值