数据结构 || 单链表学习总结

最新推荐文章于 2024-04-19 17:19:21 发布
最新推荐文章于 2024-04-19 17:19:21 发布
阅读量3.7k 收藏 28
点赞数 6
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jack_wang128801/article/details/102493117
版权

文章目录

前言
  • 在顺序表中,用一组地址连续的存储单元来存放线性表的结点,因此结点的逻辑顺序和物理顺序是一致的。
  • 链表使用一组任意的存储单元来存放线性表的结点
单链表
1.简介
  • 单链表结构图示
    在这里插入图片描述
1.1:单链表特点
  • 结点包括两个域:一个 数据域(用来存储结点的值) 和一个 指针域(用来指向该结点的直接后继结点的位置)
  • 相比于顺序表的优点:对于空间的利用率 大大提高,实现了即用既申请.
  • 相比于顺序表的缺点:在访问表中的某个结点(尾结点)时,需要遍历整个链表
2.单链表的实现
2.1:单链表结点结构的定义
typedef int SLDataType;

typedef struct SLNode{
  SLDataType _value;
  struct SLNode *next;
}SLNode;
2.2:指向链表的首结点的定义
typedef struct SList{
  SLNode *first;
}SList;
2.3:单链表头结点的初始化
//初始化
void SListInit(SList*list){
  assert(list!=NULL);
  list->first=NULL;
}
2.4:单链表的销毁
  • 算法思想
  • 1.定义一个指针指向(*cur)要销毁的结点,一个指针(*next)指向该节点的下一个结点
  • 2.用指针cur来遍历结点,并将遍历到的结点销毁
  • 3.用指针next来确保不会将单链表中其他结点丢失
  • 4.最后将指向该链表的指针置空
//需要遍历整个链表且将遍历到的结点释放掉
void SListDestory(SList *list){
  assert(list!=NULL);
  SLNode* cur=list->first;
  SLNode *next=NULL;
  while(cur!=NULL){
   next=cur->next;
   free(cur);
   cur=next;
  }
  list->first=NULL;
}
  • 动图演示
    在这里插入图片描述
2.5:单链表的头插
  • 算法思想
  • 1.申请一个新的结点,并将新结点的值置为指定的值
  • 2.让新结点的next指针指向链表原来的首结点
  • 3.让原来指针链表首结点的指针指向新结点
void SListPushFront(SList *list,SLDataType value){
  assert(list!=NULL);
  SLNode* new_node=(SLNode*)malloc(sizeof(SLNode));
  new_node->_value=value;
  new_node->next=list->first;
  list->first=new_node;
}
  • 动图演示
    在这里插入图片描述
2.6:单链表的尾插
  • 算法思想
  • 1.申请一个新的结点,并将结点的值置为指定的插入值
  • 2.遍历整个单链表,找到单链表的尾结点
  • 3.将新结点的next指针指向NULL
  • 4.原来尾节点的next指针指向新的结点
//尾插
void SListpushBack(SList *list, SLDataType value){
  assert(list!=NULL);
  //寻找尾部
  SLNode* cur=list->first;
  SLNode* new_node=(SLNode *)malloc(sizeof(SLNode));
  while(cur->next!=NULL){
    cur=cur->next;
  }
  new_node->_value=value;
  new_node->next=cur->next;
  cur->next=new_node;
}
  • 动图演示
    在这里插入图片描述
2.7:单链表结点的头删
  • 算法思想
  • 1.定义一个指向单链表首结点的指针
  • 2.将原来指向单链表首结点的指针指向它的下一个结点位置
  • 3.将原来的首结点释放
//头删
void SListPopFront(SList *list){
assert(list!=NULL);    //保证链表存在
assert(list->first!=NULL);  //保证链表不为空

SLNode *tmp=list->first;
list->first=list->first->next;
free(tmp); 
}
  • 动图演示
    在这里插入图片描述
2.8:单链表结点的尾删
  • 算法思想
  • 1.首先要确定该链表的是否只有一个结点,若是则调用头删函数即可
  • 2.若不是,就需要找到尾节点的前一个结点,再将尾节点释放
//尾删
void SListPopBack(SList *list){
  assert(list!=NULL);
  assert(list->first!=NULL);
  //如果只有一个结点需要特殊处理
  
  if(list->first->next==NULL){
    SListPopFront(list);
    return;
  }
  SLNode *cur=list->first;

  while(cur->next->next!=NULL){ 
    cur=cur->next;
  }

  free(cur->next);
  cur->next=NULL;
}
  • 动图演示
    在这里插入图片描述
2.9:单链表中指定结点的查找
  • 算法思想
  • 1.遍历整个链表查找结点值与给定值相等的结点
  • 2.若找到,则将找到的结点返回
  • 3.若没有找到,则返回NULL
//查
SLNode * SListFind(const SList *list, SLDataType value){
  assert(list!=NULL);
  assert(list->first!=NULL);
  SLNode *cur=list->first;
  while(cur!=NULL){
    if(cur->_value==value)
      return cur;
    cur=cur->next;
  }
  return NULL;
}
2.10:单链表结点值的打印
  • 算法思想
  • 1.遍历整个链表的时将各个结点的值输出
//打印
void SListPrint(SList *list){
  assert(list!=NULL);

 SLNode *cur=list->first;
  while(cur!=NULL){
    printf("%d-->",cur->_value);
    cur=cur->next;
  }
  printf("\n");
 }
2.11:修改指定结点的值
void  SlistNodeUpdate(SLNode *node, SLDataType value){
  node->_value=value;
}
2.12:在指定的位置插入新的结点
  • 算法思想
  • 1.申请新的结点,并将给定值赋给该结点
  • 2.对给定位置的结点进行"尾插"
//指定位置插入元素
//1-->2-->3-->NULL
//pos 一定是链表中的有效节点
void SListInsertAfter(SLNode *pos, SLDataType value){
  assert(pos!=NULL);
  SLNode *new_node=(SLNode*)malloc(sizeof(SLNode));
  new_node->_value=value;
  new_node->next=pos->next;
  pos->next=new_node;
}
2.13:删除指定位置下一个结点
  • 算法思想
  • 1.定义一个指针指向给定结点的下一个结点
  • 2.将给定结点的next指针指向该结点的下一个的下一个结点
  • 3.再将定义的指针指向的空间释放
//删除给定pos位置后面的结点
void SListEraseAfter(SLNode *pos){
  assert(pos!=NULL);
  SLNode* cur=pos->next;
  pos->next=pos->next->next;
  free(cur);
}
2.14:在指定位置前面插入新的结点
  • 算法思想
  • 1.在给定链表中查找给定结点的前一个结点
  • 2.申请新的结点并将给定值赋给新结点
  • 3.对给定结点的前一个结点进行"尾插"
//指定位置pos 前面插入新结点
void SListInsertBefore(SList *list, SLNode *pos, SLDataType value){
  assert(list!=NULL);
  assert(pos!=NULL);
  SLNode *new_node=(SLNode*)malloc(sizeof(SLNode));
  
  SLNode* cur=list->first;
  while(cur->next!=pos){
    cur=cur->next;
  }
 
  new_node->_value=value;
  new_node->next=pos;
  cur->next=new_node;
}
单链表功能的整体实现
SList.h
#pragma once
#include<stdlib.h>
#include<stdio.h>
#include<assert.h>


typedef int SLDataType;

typedef struct SLNode{
  SLDataType _value;
  struct SLNode *next;
}SLNode;

typedef struct SList{
  SLNode *first;
}SList;


//初始化
void SListInit(SList*list);

//销毁过程
void SListDestory(SList *list);

//增
//头插
void SListPushFront(SList *list,SLDataType value);
//尾插
void SListpushBack(SList *list, SLDataType value);





//删
//头删
void SListPopFront(SList *list);
//尾删
void SListPopBack(SList *list);

//打印
void SListPrint(SList *list);

//查
SLNode * SListFind(const SList *list, SLDataType value);

//改
void  SlistNodeUpdate(SLNode *node, SLDataType value);

//指定位置插入元素
//1-->2-->3-->NULL

void SListInsertAfter(SLNode *pos, SLDataType value);

//删除给定pos位置后面的结点
void SListEraseAfter(SLNode *pos);

//指定位置pos 前面插入新结点
void SListInsertBefore(SList *list, SLNode *pos, SLDataType value);
SList.c
#include"SList.h"
//->指针解引用
//. 变量解引用

//初始化
void SListInit(SList*list){
  assert(list!=NULL);
  list->first=NULL;
}

//销毁过程(不太熟练)
//需要遍历整个链表且将遍历到的结点释放掉
void SListDestory(SList *list){
  assert(list!=NULL);
  SLNode* cur=list->first;
  SLNode *next=NULL;
  while(cur!=NULL){
   next=cur->next;
   free(cur);
   cur=next;
  }
  list->first=NULL;
}

//增
//头插
void SListPushFront(SList *list,SLDataType value){
  assert(list!=NULL);
  SLNode* new_node=(SLNode*)malloc(sizeof(SLNode));
  new_node->_value=value;
  new_node->next=list->first;
  list->first=new_node;
}


//尾插
void SListpushBack(SList *list, SLDataType value){
  assert(list!=NULL);
  //寻找尾部
  SLNode* cur=list->first;
  SLNode* new_node=(SLNode *)malloc(sizeof(SLNode));
  while(cur->next!=NULL){
    cur=cur->next;
  }
  new_node->_value=value;
  new_node->next=cur->next;
  cur->next=new_node;
}
//删
//头删

void SListPopFront(SList *list){
assert(list!=NULL);    //保证链表存在
assert(list->first!=NULL);  //保证链表不为空

SLNode *tmp=list->first;
list->first=list->first->next;
free(tmp); 
}

//尾删
void SListPopBack(SList *list){
  assert(list!=NULL);
  assert(list->first!=NULL);
  //如果只有一个结点需要特殊处理
  
  if(list->first->next==NULL){
    SListPopFront(list);
    return;
  }
  SLNode *cur=list->first;

  while(cur->next->next!=NULL){ 
    cur=cur->next;
  }

  free(cur->next);
  cur->next=NULL;
}

//打印
void SListPrint(SList *list){
  assert(list!=NULL);

 SLNode *cur=list->first;
  while(cur!=NULL){
    printf("%d-->",cur->_value);
    cur=cur->next;
  }
  printf("\n");
 }

//查
SLNode * SListFind(const SList *list, SLDataType value){
  assert(list!=NULL);
  assert(list->first!=NULL);
  SLNode *cur=list->first;
  while(cur!=NULL){
    if(cur->_value==value)
      return cur;
    cur=cur->next;
  }
  return NULL;
}

//改
void  SlistNodeUpdate(SLNode *node, SLDataType value){
  node->_value=value;
}

//指定位置插入元素
//1-->2-->3-->NULL
//pos 一定是链表中的有效节点
void SListInsertAfter(SLNode *pos, SLDataType value){
  assert(pos!=NULL);
  SLNode *new_node=(SLNode*)malloc(sizeof(SLNode));
  new_node->_value=value;
  new_node->next=pos->next;
  pos->next=new_node;
}

//删除给定pos位置后面的结点
void SListEraseAfter(SLNode *pos){
  assert(pos!=NULL);
  SLNode* cur=pos->next;
  pos->next=pos->next->next;
  free(cur);
}

//指定位置pos 前面插入新结点
void SListInsertBefore(SList *list, SLNode *pos, SLDataType value){
  assert(list!=NULL);
  assert(pos!=NULL);
  SLNode *new_node=(SLNode*)malloc(sizeof(SLNode));
  
  SLNode* cur=list->first;
  while(cur->next!=pos){
    cur=cur->next;
  }
 
  new_node->_value=value;
  new_node->next=pos;
  cur->next=new_node;
}
main.c
#include"SList.h"



void TestSLNode(){
  SList slist;
  SListInit(&slist);
  SListPushFront(&slist,1);
  SListPushFront(&slist,9);
  //9  1
  SListPrint(&slist);
  SListPushFront(&slist,8);
  SListPrint(&slist);
  // 8 9 1
  SListPushFront(&slist,5);
  SListPrint(&slist);
  // 5 8 9 1
  SListpushBack(&slist,4);
  SListpushBack(&slist,3);
  SListpushBack(&slist,2);
  SListpushBack(&slist,100);
  SListPrint(&slist);
  //5 8 9 1 4 3 2 100
  SListPopFront(&slist);
  // 8 9 1 4 3 2 100
  SListPopBack(&slist);
  SListPrint(&slist);
  // 8  9 1 4 3 2 
  SListPopFront(&slist);
  //9  1 4 3 2 
  SListPrint(&slist);
  SLNode* node=SListFind(&slist,3);
  SListEraseAfter(node);
  // 9  1 4 3 
  SListInsertAfter(node,520);
  // 9 1 4 3 520
  SListPrint(&slist);
  SListEraseAfter(node);
  // 9 1 4 3 
  SListInsertBefore(&slist,node,1314);
  // 9 1 4   1314 3 
  SListPrint(&slist);
}

int  main()
{
  TestSLNode();
  return 0;
}
iTXCode
关注
  • 6
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表实验报告
03-11
数据结构实验报告:单链表的建立 1．实验目的 （1）了解数据的逻辑结构和数据的存储结构之间的区别与联系； （2）掌握线性表的链式表示和实现方法，特别是插入、删除操作。 （3）掌握运用C语言上机调试线性表的基本方法。 2．实验内容 （1）建立一个类型为整型链接表的头文件和基本操作，特别是初始化操作、插入操作、删除操作、查找操作、遍历操作等。 （2）创建有10个元素的线性链接表，验证插入、删除、查找操作的结果 3．实验步骤 在微型计算机上调试编写的程序，记录运行结果。
数据结构学习心得——单链表
热门推荐
Xiaowei's Blog
08-17 1万+
一、线性表的存储结构 顺序表（顺序表操作见上一篇博客） 链表 在链表存储中，每个结点不仅包含所有的元素的信息，还包含元素之间逻辑关系的信息，如单链表中前驱结点包含后继结点的地址信息，这样就可以通过前驱结点中的地址信息找到后继结点的位置。 （2）单列表 在每个节点中除了包含数据域外，还包含一个指针域，用以指向其后继结点。下图所示为带头结点的单链表。 a.带头结点的单链表中，头指针head指
单链表（详解）
最新发布
的博客
04-19 743
链表在物理结构上不一定是连续的在逻辑结构上一定是连续的（可以通过前一个节点的指针找到下一个节点）链表是由一个一个的节点组成的，一个节点存储：指向下一个节点的指针和一个任意类型的数据由此可以知道链表可以通过前一个节点的指针找到下一个节点，各个节点就串联起来了也可以把链表类比成一列火车，火车（链表）有一列列车厢（节点）组成。
单链表的体会
weixin_72839892的博客
04-03 4667
在实际编程中，单链表常常用于解决需要动态变化长度和频繁插入和删除节点的问题，具有广泛的应用场景。通过深入理解单链表的实现原理，可以更好地理解其他数据结构和算法，并能够更加高效地解决实际问题。单链表是一种常见的数据结构，由节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。单链表的优点是插入和删除节点比较容易，时间复杂度为O(1)，同时可以动态变化长度，不需要预分配内存空间。但是访问节点的时间复杂度较高，需要遍历整个链表。通过学习和实现单链表，可以加深对数据结构和算法的理解，并提高编程能力。
单链表的学习笔记
weixin_61023150的博客
04-27 2502
1.写在前面 本文主要是用于记录单链表章节的学习心得，在闵老代码的基础上进行不断的完善，以达到学习认识单链表的目的。可能仍有疏漏之处，还望批评指正。 2.主要组成部分 1).定义单链表类型 本步骤的目的在于，定义后续的表，以及代替表进行工作的的指针。 代码实现如下： "" typedef struct LinkNode { char data; struct LinkNode *next; ...
单链表的学习总结
Peter_tang6的博客
08-01 7105
前面学习了单链表的一些基本操作，这篇文章对在学习单链表的过程中遇到的一些问题做一些总结。初学单链表，很多东西都很难理解，因为之前的C语言基础的指针这块不是很熟悉，对于指针的操作很模糊，在一边百度一边看视频学习的过程中，渐渐加深了对指针的理解，以及对程序的模块化编程的学习。分不清楚头结点和头指针我学习的是没有头结点的，即只有一个头指针，在写代码的时候我总是会把头指针误认为一个头结点，然后定义另一个指针
关于c语言链表的学习总结
07-21
我这些天在学习数据结构，发现了一些问题。闲话少叙，先上代码（参考教材：数据结构-c语言，耿国华编著，有删改）。
数据结构历次算法总结.docx
06-12
本人数据结构课程学习中的历次代码，包括但不完全包含多项式导数，约瑟夫环，二叉树等，买不了吃亏，买不了上当，总有一个适合你的数据结构作业
C语言实现通讯录制作-链表学习案例
10-25
C语言实现通讯录制作-链表学习案例文章所提到源码 学习数据结构中链表部分的总结 可以在C语言实训或数据结构课程设计中使用 代码相对来说还有许多地方可以改进，希望大家指出 全部内容均由本人所写算法实现
无头节点的单链表
07-17
回看了一下自己写的这个单链表的实现，注释写的非常详细了，包括了单链表中二级指针的应用场景，为什么要使用二级指针这些问题都有一个详细的总结，也包括链表节点的结构体和学生个人信息结构体的这些区分。...
数据结构实验指导书(单链表验证二叉树图的存储)
12-21
数据结构实验是一种自主性很强的学习过程，其教学目的主要有两个:(1)深化理解和掌握书本上的理论知识，将书本上的知识变“活”；(2)理论和实践相结合，使学生学会如何把书本上有关数据结构和算法的知识用于解决实际...
数据结构之单链表实验报告
06-13
数据结构之单链表实验报告 数据结构之单链表实验报告 做的很全的 。适合计算机与学习数据结构课程的所有本专科学生。
数据结构--单链表操作实验报告
04-12
1.从键盘输入顺序任意的5个整数，按有序插入的要求生成第一个有序单链表，将该链表输出显示。 2.再从键盘输入顺序任意的5个整数，按有序插入的要求生成第二个有序单链表，将该链表输出显示。 3.将这两个有序单链表合并成一个有序单链表，要求使用两个单链表的原有空间进行合并，将生成的有序单链表输出显示。
单链表实验报告（C++）
06-24
单链表的C++实现，实验报告加代码都在里面了，代码分成几个文件的，如果要运行记得分开
数据结构 | 单向链表学习总结
lovetaozibaby的博客
09-02 3762
文章目录简介总结链表介绍链表定义链表函数计算链表的长度将列表转换为链表LeetCode：剑指 Offer 22. 链表中倒数第k个节点 简介 今天打开力扣每日一题，遇到一个新的数据结构：链表。 本来每次力扣做题我都是在我自己的本地python调试，调试好后才提交到网上。但是今天遇到一个问题：力扣的测试用例写的是：[1,2,3,4,5]，我在写测试用例的时候，也写了：input = [1,2,3,4,5]，但是官方的程序竟然都通不过。 后来查找问题的时候才意识到，如果我以input = [1,2,3,4,5]
[个人心得]数据结构之单链表
weixin_33856370的博客
12-04 458
维基百科 链表是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针。 链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的下一个节点，而最后一个节点则指向一个空值。 一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。 一般查找...
单链表的学习心得
lin1214000999的博客
02-20 2329
package com.yg.linkedList;/* @author Ge @date 2020/2/19 15:01 */ import javax.validation.constraints.Pattern; import java.util.Stack; public class SingleLinkedListDemo { public static void ...
单链表学习总结
neuq1141的专栏
10-22 663
这是在vc6.0上敲的有关单链表的算法。 //单链表的创建、遍历、插入、删除、冒泡排序、逆序 #include #include #include //定义单链表的结构体 typedef struct Node{           int data; //存放数据  struct Node *next; //存放指针 }NODE, *PNODE; //创建单链表
【数据结构】链表的学习总结
Pursue quality, not quantity.
08-07 2858
初阶_数据结构
数据结构与算法c语言单链表
09-19
单链表是一种经典的链式存储结构，它由一个包含数据和指向下一个节点的指针的节点构成。单链表的创建有头插法和尾插法两种方法。头插法将新创建的节点插入到头节点之后，而尾插法将新创建的节点插入到尾节点之后。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值