链接表操作：遍历、插入和删除

已于 2023-08-07 21:30:56 修改
阅读量946 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： 算法
于 2023-08-07 21:30:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ntr851217/article/details/132105191
版权

什么是链表？

链表是一种线性数据结构，包括一系列相连的结点。在这里，每个节点都存储数据和下一个节点的地址。例如：

linked list data structure

链表有多种类型：单链表、双链表和循环链表。这里仅介绍单链表。

链表的简单示例

这里我用一个结构体来封装一个结点，对于每一个结点都包含：

  • 数据域
  • 指向下个结点的next指针 
struct node
{
  int data;
  struct node *next;
};

 下面我将创建一个包含三个结点的链表：

representing linked list by connecting each node with next node using address of next node

 具体实现：

#include <bits/stdc++.h>
#include <iostream>
using namespace std;

// 创建一个结点
class Node {
   public:
  int value;
  Node* next;
};

int main() {
  Node* head;
  Node* one = NULL;
  Node* two = NULL;
  Node* three = NULL;

  // 为三个结点分配内存
  one = new Node();
  two = new Node();
  three = new Node();

  // 分配数据域的值
  one->value = 1;
  two->value = 2;
  three->value = 3;

  // 链接结点
  one->next = two;
  two->next = three;
  three->next = NULL;

  // 打印结点的值
  head = one;
  while (head != NULL) {
    cout << head->value;
    head = head->next;
  }
}

遍历链表 

当我们想要遍历一个链表时，需要一个临时结点来存储当前所遍历的结点，每次循环都指向它的下一个结点，直到这个临时结点指向NULL，跳出循环。

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

 运行结果：

List elements are - 
1 --->2 --->3 --->

从链表中插入一个结点

1.在表头插入一个结点

Lightbox

在表头插入一个结点的步骤：

  • 为新结点分配内存
  • 存储数据
  • 改变新结点的next指针到头指针
  • 改变头指针到新结点
struct node *newNode;
newNode = malloc(sizeof(struct node));
newNode->data = 4;
newNode->next = head;
head = newNode;

2.在表尾插入一个结点 

Lightbox

 在表尾插入一个结点的步骤：

  • 为新结点分配内存
  • 存储数据
  • 遍历最后一个结点
  • 将最后结点的next指向新结点
struct node *newNode;
newNode = malloc(sizeof(struct node));
newNode->data = 4;
newNode->next = NULL;

struct node *temp = head;
while(temp->next != NULL){
  temp = temp->next;
}

temp->next = newNode;

3.在中间位置插入一个结点 

在中间位置插入一个结点的步骤：

  • 为结点分配内存
  • 存储数据
  • 遍历到新节点所需位置前的节点
  • 更改next指针到两者之间
struct node *newNode;
newNode = malloc(sizeof(struct node));
newNode->data = 4;

struct node *temp = head;

for(int i=2; i < position; i++) {
  if(temp->next != NULL) {
    temp = temp->next;
  }
}
newNode->next = temp->next;
temp->next = newNode;

从链表中删除一个结点 

1. 删除头结点

  • 将头指针指向下一个结点
head = head->next;

2. 删除尾结点

  • 遍历到倒数第二个元素
  • 更改它的next指针为NULL
struct node* temp = head;
while(temp->next->next!=NULL){
  temp = temp->next;
}
temp->next = NULL;

3. 在中间删除一个结点

  • 遍历到要删除元素的前一个元素
  • 更改next指针并将此结点删除
for(int i=2; i< position; i++) {
  if(temp->next!=NULL) {
    temp = temp->next;
  }
}

temp->next = temp->next->next;

 在一个链表中查找一个元素

  • 将头设为当前结点
  • 执行该循环直到当前结点指向NULL
  • 执行每一次的迭代，检查结点的键值是否与我们要找到键值相等，如果相等返回true，循环结束返回false
// 查找一个结点
bool searchNode(struct Node** head_ref, int key) {
  struct Node* current = *head_ref;

  while (current != NULL) {
    if (current->data == key) return true;
      current = current->next;
  }
  return false;
}

 对链接列表中的元素排序

下面我们将使用一种简单的排序算法--冒泡排序，对链表中的元素进行升序排序。

  1. 将头作为当前节点，并创建另一个节点索引供以后使用。
  2. 如果 head 为空，则返回。
  3. 否则，运行循环直到最后一个节点（即 NULL）。
  4. 每次迭代都要遵循以下步骤 5-6。
  5. 用索引存储当前节点的下一个节点。
  6. 检查当前节点的数据是否大于下一个节点。如果大于，则交换当前节点和索引。
// 排序此链表
void sortLinkedList(struct Node** head_ref) {
  struct Node *current = *head_ref, *index = NULL;
  int temp;

  if (head_ref == NULL) {
    return;
  } else {
    while (current != NULL) {
      
      index = current->next;

  	while (index != NULL) {
        if (current->data > index->data) {
          temp = current->data;
          current->data = index->data;
          index->data = temp;
    	  }
    	  index = index->next;
  	}
  	current = current->next;
    }
  }
}

 链表在c++中的操作

// 链表在c++中的操作

#include <stdlib.h>

#include <iostream>
using namespace std;

// 创建一个结点
struct Node {
  int data;
  struct Node* next;
};

void insertAtBeginning(struct Node** head_ref, int new_data) {
  // 为结点分配内存
  struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));

  // 插入这个数据
  new_node->data = new_data;
  new_node->next = (*head_ref);

  // 移动头到新结点
  (*head_ref) = new_node;
}

// 在一个结点后插入一个结点
void insertAfter(struct Node* prev_node, int new_data) {
  if (prev_node == NULL) {
  cout << "the given previous node cannot be NULL";
  return;
  }

  struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
  new_node->data = new_data;
  new_node->next = prev_node->next;
  prev_node->next = new_node;
}

// 在尾部插入
void insertAtEnd(struct Node** head_ref, int new_data) {
  struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
  struct Node* last = *head_ref; /* 用于步骤 5*/

  new_node->data = new_data;
  new_node->next = NULL;

  if (*head_ref == NULL) {
  *head_ref = new_node;
  return;
  }

  while (last->next != NULL) last = last->next;

  last->next = new_node;
  return;
}

// 删除节点
void deleteNode(struct Node** head_ref, int key) {
  struct Node *temp = *head_ref, *prev;

  if (temp != NULL && temp->data == key) {
  *head_ref = temp->next;
  free(temp);
  return;
  }
  // 找到要删除的键值
  while (temp != NULL && temp->data != key) {
  prev = temp;
  temp = temp->next;
  }

  // 如果键值不存在
  if (temp == NULL) return;

  // 删除此结点
  prev->next = temp->next;

  free(temp);
}

// 查找结点
bool searchNode(struct Node** head_ref, int key) {
  struct Node* current = *head_ref;

  while (current != NULL) {
  if (current->data == key) return true;
  current = current->next;
  }
  return false;
}

// 链表排序
void sortLinkedList(struct Node** head_ref) {
  struct Node *current = *head_ref, *index = NULL;
  int temp;

  if (head_ref == NULL) {
  return;
  } else {
  while (current != NULL) {
    //索引指向当前的next
    index = current->next;

    while (index != NULL) {
    if (current->data > index->data) {
      temp = current->data;
      current->data = index->data;
      index->data = temp;
    }
    index = index->next;
    }
    current = current->next;
  }
  }
}

// 打印此链表
void printList(struct Node* node) {
  while (node != NULL) {
  cout << node->data << " ";
  node = node->next;
  }
}

// 驱动程序
int main() {
  struct Node* head = NULL;

  insertAtEnd(&head, 1);
  insertAtBeginning(&head, 2);
  insertAtBeginning(&head, 3);
  insertAtEnd(&head, 4);
  insertAfter(head->next, 5);

  cout << "Linked list: ";
  printList(head);

  cout << "\nAfter deleting an element: ";
  deleteNode(&head, 3);
  printList(head);

  int item_to_find = 3;
  if (searchNode(&head, item_to_find)) {
  cout << endl << item_to_find << " is found";
  } else {
  cout << endl << item_to_find << " is not found";
  }

  sortLinkedList(&head);
  cout << "\nSorted List: ";
  printList(head);
}

无限酸奶
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言实现链表，创建、插入、查找、删除、遍历等基本操作
09-13
C与语言实现链表的创建、插入（头插法、尾插法）、遍历、查找、删除操作
C语言数据结构 单链表的建立、遍历、查找、插入和删除操作
热门推荐
追求。
04-26 1万+
链表（Linked List）是一种物理存储单元上非连续、非顺序的数据结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（node，链表中每一个元素称为结点）组成，每一次为一个结构体 动态分配的内存空间，可称之为一个结点，每个结点之间可以是不连续的，但结点内是连续的。结点个数是不受限定的，可以随时删改，这是与数组相比的优点。.........
matlab链表操作,Go语言链表操作
weixin_39895486的博客
03-25 233
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。使用链表结构可以避免在使用数组时需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数...
数据结构与算法（六）--链表的遍历，查询和修改，删除操作
学习不止境的博客
09-22 711
我们了解了链表的概念以及链表底层的搭建以及向链表中添加元素的操作。本次我们继续学习链表剩余的操作：遍历，查询和修改、删除操作。
1.（3）数据结构之链表的创建和遍历（有图有注释）
爱打羽毛球的程序员
07-23 3633
数据结构之链表的创建和遍历（有图有注释）快速看懂创建和遍历过程
python - 链表遍历输出的3种方法
qq_30869745的博客
11-04 3874
使用yield & list def items(self): current=self.head while current !=None: yield current.data current=current.getNext() for i in range(5): myList.add(i) print(list(myList.items())) # [4, 3,
链表（四）遍历链表
m0_60977861的博客
03-17 7182
从链表头开始，涉及整个链表，在每个结点上操作的过程称为遍历链表 假设链表的链表头指针是namelist，要遍历链表，则需要另一个指针ptr指向链表的开头。 listnode* ptr = head; 然后可以使用表达式*ptr或者结构指针操作符->处理由ptr指向的结点。 需要打印节点上的值 cout << ptr->name << endl; 一旦该节点打印完毕，那么指针将会移动到下一个节点 ptr = ptr -> next1; 以上语句
链表的概述，节点的定义，链表的创建，链表的遍历
yhxz1的博客
03-20 1278
链表的基础内容，创建方式，遍历方式
链表的插入与删除
yyyy11665的博客
08-14 6090
.实现链表的三种删除方法：头删法，尾删法，中间删除法。1.实现链表的三种插入方法：头插法，尾插法，中间插入。*同时为了验证结果实现了链表的显示。
单链表的遍历
m0_57248752的博客
03-13 1952
单链表的简单介绍和遍历
DAY3:链表（一）：链表基础知识+移除链表元素
CFY1226的博客
05-13 2242
/ 单链表的定义 struct ListNode {int val;//节点上储存的元素 ListNode * next;//指向下一个节点的指针 ListNode(int x) : val(x) , next(NULL) {//节点的构造函数 } }//定义指针，指向链表对象（虚拟头节点用法）所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！首先，你需要一个指针来找到要删除的节点。这个指针通常是通过遍历链表得到的。
JavaScript 双向链表操作实例分析【创建、增加、查找、删除等】
11-21
开始节点和结束节点的上一个链接和下一个链接分别指向某种终止节点，通常是前哨节点或null，以方便遍历列表。如果只有一个前哨节点，则列表通过前哨节点循环链接。它可以被概念化为两个由相同数据项组成的单链表，但...
LinkedListQueue:具有通用链表的队列的实现
06-14
链接列表允许在列表中的任何点插入和删除，并且如果在列表遍历期间保留了指向要添加或删除的链接的前一个链接，则可以使用恒定数量的操作来执行此操作。 另一方面，简单的链表本身不允许随机访问数据或任何形
实验六 图基本操作的编程实现
02-09
图基本操作的编程实现（2学时，验证型），掌握图的建立、遍历、插入、删除等基本操作的编程实现，存储结构可以在顺序结构、链接结构、联合使用多种结构等中任选，也可以全部实现。也鼓励学生利用基本操作进行一些...
基于Linux的内核链表源代码
08-20
我们无法通过一套泛性的、普遍适用的操作函数来访问所有的链表，意味着我们设计一个链表就得写一套链表的操作函数（节点创建、插入、删除、遍历……）。 （2）实际上深层次分析会发现 不同的链表虽然这些方法不能...
Rapidly exploring Random Trees(RRT)类算法
qq_35635374的博客
04-28 421
认知有限，望大家多多包涵，有什么问题也希望能够与大家多交流，共同成长！本文先对Rapidly exploring Random Trees(RRT)类算法做个简单的介绍，具体内容后续再更，其他模块可以参考去我其他文章提示：以下是本篇文章正文内容（1）优点快速随机树算法是一种较为迅捷搜索的方式，增量式的构建树其优点明显，主要体现在针对性的找一条从起点到终点的路径其较强较快的搜索能力，【防盗标记–盒子君hzj】并且运用快速拓展随机树的路径规划对路径运行环境没有限制要求。（2）缺点。
笔试强训-day17_T2 十字爆破
最新发布
weixin_46186903的博客
05-03 642
模拟即可，但是由于数据量过⼤，我们可以提前把每⼀⾏以及每⼀列的和存起来，⽅便统计总和。解法二：提前把每⼀⾏以及每⼀列的和存起来，然后输入输出使用快速的IO方式，解答如下所示。解法一：暴力遍历，这种方法很容易想到，并且也容易编写出代码，但是会超时。因为1+2+3=6，1+2+4=7，1+3+4=8，2+3+4=9。牛牛选择一个方格，可以得到和这个方格同行、同列的所有数之和的得分。现在牛牛想知道下一步选择每个格子的得分情况，你可以帮帮他吗？m个方格，每个方格中有一个整数。
leetcode16-3Sum Closest
我的程序人生
04-29 332
这道题目和那道3Num的题目很类似，解题思路也是类似的，我们先对数组排序，然后固定一个元素，通过双指针遍历剩下的元素，用一个哨兵记录三个元素的和与target的diff，分别处理三个元素的和小于target，大于target，等于target这三种情况即可。请你从 nums 中选出三个整数，使它们的和与 target 最接近。解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2)。输入：nums = [-1,2,1,-4], target = 1。假定每组输入只存在恰好一个解。
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真
熟悉MATLAB/fpga/RK3588/LABVIEW/protus/单片机/dsp/Multisim
04-30 661
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真。基于模糊PI控制算法的龙格-库塔（Runge-Kutta, RK）连续搅拌釜反应器（Continuous Stirred Tank Reactor, CSTR）模型控制系统，是将模糊控制理论与经典的数值积分方法相结合的一种先进控制策略。模糊控制是一种基于模糊集合理论和语言变量的控制方法，适用于非线性、时变系统的控制。
C++ 链表遍历
05-25
C++ 中的链表遍历可以使用循环或递归两种方式实现。 循环遍历： ```c++ struct ListNode { int val; ListNode* next; ListNode(int x) : val(x), next(NULL) {} }; void traverseList(ListNode* head) { ListNode* cur = head; while (cur != NULL) { // 处理当前节点 cout << cur->val << " "; // 移动到下一个节点 cur = cur->next; } } ``` 递归遍历： ```c++ void traverseList(ListNode* head) { if (head == NULL) { return; } // 处理当前节点 cout << head->val << " "; // 遍历下一个节点 traverseList(head->next); } ``` 以上两种方式都可以实现链表的遍历，循环方式通常更加高效，而递归方式则更加简洁易懂。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

无限酸奶

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

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

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

打赏作者

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

抵扣说明：

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

余额充值