数据结构学习笔记——链表

最新推荐文章于 2022-10-10 18:46:16 发布
最新推荐文章于 2022-10-10 18:46:16 发布
阅读量385 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41812260/article/details/105095283
版权

文章目录

1.什么是链表？

我的理解是：链表就是由一系列的节点组成，而每个节点又包括了两个部分；一部分是数据域，用来储存数据，另一部分指针域，用来指向下一节点。最后把这些节点串起来就形成了链表。

1.1节点构造

struct list_node
{
    int     data ; // 定义数据域，用于存储数据  
    struct  list_node *next ; //定义指针域，可以用来访问节点数据，也可以遍历，指向下一个节点

};

1.2链表的构造

首先了解链表的组成部分：
在这里插入图片描述
说明：
头节点：在单链表的第一个结点之前附设一个结点，它没有直接前驱，称之为头结点，头结点的数据域可以不存储任何信息，指针域指向第一个节点（首节点）的地址。头结点的作用是使所有链表（包括空表）的头指针非空。

2.创建链表

2.1 单向链表

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

struct list_node     //定义结构体
{
int      data ;       //数据域
struct   list_node *next ;   //指针域
}
typedef struct list_node list_single ;

int main(void)
{
      list_single      *node = NULL ; //定义一个头指针

node = (list_single *)malloc(sizeof(list_single)); //分配内存空间

if(node == NULL)
{
     printf("分配空间失败\n");
}

    memset(node,0,sizeof(list_single)); //清空
    node->data = 123 ;        //给链表节点的数据域赋值
    node->next = NULL ;      //将链表的指针域指向空

      printf("node_data=%d\n",node->data);
      printf("node_next=%d\n",node->next);
      free(node);

 return 0 ;

}

运行结果：
在这里插入图片描述
该链表就是：

在这里插入图片描述上述程序中出现了malloc函数，该函数分配的内存大小至少为参数所指定的字节数 ，而且malloc和free是配对的，如果申请后不释放就是内存泄露，如果无故释放那就是什么也没做，释放只能释放一次，如果一块空间释放两次或者两次以上会出现错误（但是释放空指针例外，释放空指针也等于什么也没做，所以释放多少次都是可以的。）
详细解释可以参考：malloc函数详解

2.2遍历输出链表

void looklist（）
           struct list_node *newp =head;     //定义一个临时变量指向头节点
           //通过循环遍历整个链表并输出
           while（newp != NULL ）
           {
               printf("%d\n",newp->data);
               newp = newp->next;
           }

2.3查询链表某节点

struct Node* FindNode(int a )
{
    struct list_node *newp=head;
    while（ newp ！= NULL）  //遍历整个链表
    {
        if(data == temp->data)     //找到则返回该节点
             return temp;
         temp = temp->next;
    }
         return NULL;    //未找到
}

2.4尾增加一个节点

void addlist（int data）
{
      //创建一个新节点，并申请内存空间
      struct list_node* newp=(struct list_node*)malloc(sizeof(struct list_node));
      //第一种是链表为空，即一个节点也没有
      if（head = NULL ）
      {
           head = newp；
      }
      else//第二种链表不为空
      {
             end->next=newp;
      }
      end = newp； //尾结点始终指向最后一个
}

2.5尾删除一个节点

void delectend（）
{
       //第一种链表为空
       if（end = NULL）
       { 
              printf("链表为空，无需删除\n");
              return 0；
       }
       //第二种链表不为空
       //只有一个节点
       if (head == end)
       {
              free(head);
              head=NULL;
	      end=NULL; 
       }
       else //多个节点
       {
             struct list-node* newp =head; 
             while (temp->next!=end)//找到尾部
             {
                  newp= newp->next;
             }

             //释放尾巴
             free(end);
             //再将倒数第二个设为end
            end=temp;
           //尾巴指针为NULL
           end->next=NULL;

       }
}

2.6头删除一个节点

void delecthead（）
{
    struct list_node* newp=head;   //保留旧头
    //判断是否为空
    if（NULL == head）
    {
          printf("链表为空，无需删除\n");
          return 0；
    }  
    
    head=head->next;//头的第二个节点变成新的头
    free(newp);      //将旧头空间释放
}

2.7删除指定节点

void delectlist（int data）
{
   //判断链表是否为空
   if(NULL==head)
   {
       printf("链表为空，无需删除\n");
       return 0；
   }
   //不为空，则遍历链表找到这个节点
   struct list_node* newp = head
       while(newp !=NULL)
       {
           if(data == newp->data)
           {
                  return newp;
           }
           newp = newp->next;
       }
       if(NULL == newp)
       {
           printf("查无此点\n");
           return 0；
       }
       if(head==end)  //只有一个节点
       {
            free(head);
            head = NULL；
            end=NULL;
       }
       else if(head->next==end) //有两个节点
       { if(end==newp)
           { 	delestend(); }
       else if（newp==head）
           {	delecthead(); }
       }
       else //多个节点时
       {
            //看是删除头还是删除尾
            if(end==newp)
                 delectend();
            else if(temp==newp)
                 delecthead();
            else
            {  //遍历，找到需要删除的前一个
                   struct list_node*pt =head;
                   while(pt->next!=newp)
                   {
                        pt=pt->next;
                   }
                    pt->next=newp->next;
                    free （newp）；
            }
       }
     }

如图所示如图所示

2.8增加指定节点

void addlist(int index,int data)
{
//首先判断是否为空
      if (NULL==head)
      {
            printf("链表为空\n");
            return 0 ；
      }
      struct list_node* pt =FindNode(index);   //调用之前定义的查询
     
      if(NULL==pt)    //没有此节点
      {
               printf("没有找到指定节点\n");
               return 0；
      }     
      //若有节点，则创建临时节点
      struct list_node* newp =(struct Node *)malloc(sizeof(struct Node));
      newp->data=data;
      newp->next=NULL;

      if (pt == end)   //末端插入
      {
         end->next=newp;
         end=newp;
      }
      else   //中间插入
      {
           newp->next=pt->next;
           pt->next=newp;
      }
}

在这里插入图片描述
在中间也类似。

2.9 主函数

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

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

struct  list_node* head= NULL;
struct  list_node* end = NULL;
//定义链表头尾指针

void main ()
{

    struct Node* FindNode；
    for（i=0;i<10;i++）
    addlist(i);    //直接调用之前的2.4中的函数，进行链表的生成

/*     delectend（）；  //删除尾节点
     delectlist（5）；   //删除第五个节点
   */  
     looklist（）        //遍历链表，输出
          
}

3.单向和双向循环链表

1.单向循环链表
就是表的最后一个元素指向了头节点而不是为空（null）
在这里插入图片描述

2.双向循环链表
相当于两个单向循环链表的叠加。
在这里插入图片描述

4.总结

通过一段时间leetcode网站的刷题，发现了自己的很多问题，之前学习的基础知识不够扎实，在刷题有很多时候一道题需要很长的时间，而且很多答案不是特别看得懂，思路不清晰，所以打算整理一下一些数据结构方面的基础。

Y.J.N
关注
C#数据结构学习笔记——链表
a984500801的博客
02-19 5161
链表
C语言学习笔记——链表
weixin_51215586的博客
10-10 540
链表 链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。 与数组不同，链表很灵活。数组是在连续的空间里面存放元素的地址，因此很难实现数据的增删。 而链表只需修改指针的指向就能实现。 链表有一个 头指针 变量，它存放一个地址，该地址指向一个元素，链表中每一个元素称为 结点，每个结点都应包括两个部分，一为用户需要用的实际数据，二为下一个结点的地址。可以看出，头指针 head 指向第一个元素，第一个元素又指向第二个元素，。。。。直到最后一个元素，该元素不再指向其他元素，它称为 表尾，它的地
数据结构学习笔记之一:链表
热门推荐
冯立彬的博客
04-19 1万+
原貼作者BOLG:http://blog.csdn.net/woolceo/许多人都知道链表(C语言)都是借助指针来实现链接的,同样许多人也知道java语言是没有指针的,所以很多人可能很理所当然的认为"java没有数据结构",我想这种想法是错误的.程序=算法+数据结构,任何语言都离不开数据结构(唉,这么简单一个道理我也是最近才悟出的,惭愧啊...).下面我就谈谈java语言的数据结构.代码
数据结构学习笔记（一）：链表（linked list）
文程序公子的博客
05-11 1694
数据结构学习笔记（一）：常见数据结构及其增删查操作 1 链表（linked list） 链表，又称线性表或线性链表，是若干数据元素组成的线性序列，将数据元素像链条一样组织在一起。存储在链表中的数据元素被称为结点（node）,每个结点具有两个要素：第一、数据元素的具体值，第二、指向下一个结点的指针，指针用来存储下一个结点的内存地址。 最基本的链表结构是单向链表，最前面是一个头指针用来指向第一个结点，最后一个结点的指针是一个空指针（null pointer），每一个结点都只指向它的下一个结点，例如一个存储
数据结构 链表学习笔记 2
weixin_34179968的博客
04-27 82
Seqlish.h#include<stdio.h> #include<string.h> #defineMAXSIZE100//定义线性表的最大长度 typedefstruct//定义顺序表结构 { DATAListData[MAXSIZE+1];//保存顺序表的数组 intListLen; // 顺序表已存节点的数...
学习笔记 - 数据结构：链表理论
chen_holy的博客
04-28 163
总结 数组与链表优缺点对比 数组： 优点：支持随机访问，读取数据快，单个元素消耗空间少 缺点：引起大量数据迁移会耗费较多时间 链表: 优点：适合有序数据的插入与删除 缺点：单个元素消耗空间多 双向链表的优点： 支持向前遍历 循环链表的优点： 更方便实现循环操作（如：约瑟夫问题） ...
数据结构学习笔记-链表
liumokairui的专栏
04-28 668
算法的复杂度：
数据结构学习笔记——单链表
12-21
数据结构是计算机科学中至关重要的基础概念，它们用于有效地组织和管理数据，以便进行高效的存储、检索和操作。本文将深入探讨单链表这一常见数据结构，并与其他数据结构如数组进行对比。 单链表是一种线性数据结构...
《Java数据结构和算法》学习笔记(4)——链表
03-14
本文将深入探讨链表这一重要的线性数据结构，并通过源码分析来理解其工作原理。 链表是一种非连续、非顺序的存储结构，它的每个元素（称为节点）包含两部分：数据域和指针域。数据域存储实际的数据，而指针域指向下...
C#数据结构学习笔记——栈
a984500801的博客
02-19 1045
1. 栈 先进后出是栈。只能一端进行添加(入栈)或删除(出栈)操作，这一端叫栈顶。应用例如：数组反转、递归。栈的具体操作(Stack): 往栈中插入元素：void Push(e)： 取出栈顶元素并删除：E Pop() 查看栈顶元素：E Peek() 栈中数组元素数量：int Count { get; } 栈是否空：bool IsEmpty { get; } 设计栈接口来实现 interface IStack<E> { int Count { get
数据结构-单链表（学习笔记）
YYYJ_BOY的博客
04-26 1489
一、单链表的结点数据类型 typedef int DataType; struct Node { DataTpye data; struct Node *next; //next为指向下一结点的指针 }; 二、初始化单链表 int InitList(Node *&H) { H = new Node; //分配空间，作为头结点 if(!H) { cout<<"...
数据结构——链表笔记
最新发布
qq_40631525的博客
10-10 219
数据结构中最基础且简单的部分就是线性结构的链表。数据结构之后的内容都能经常见到与链表操作相似的部分。理解和掌握链表，对于数据结构之后的学习至关重要。
数据结构之链表笔记
weixin_46312914的博客
09-28 118
链表 专业术语 首节点：第一个有效节点 尾结点：最后一个有效节点 头结点： 头结点的数据类型和首节点一样 是第一个有效节点之前的那个节点 头结点不存放有效数据 加头结点的目的主要是为了方便对链表的操作 头指针：指向头结点的指针变量 尾指针：指向尾结点的指针变量! 链表的操作 1.节点的建立 typedef struct Node{ int data ;//数据域 Node * next;//指针域 }Node,*pNode; 2.链表的建立 1
数据结构笔记（一） 链表
糯米团子的博客
08-04 364
链表的定义 链表是一种动态的数据结构，其中所有数据元素(data elements)彼此链接。链表是节点的集合，每个节点包含两部分数据(data)部分和地址(address)部分。 链表的优点 动态数据结构：链表是种动态数据结构，在程序执行期间可以随意增加或减少节点。没有内存浪费：链表是在程序执行时，主动分配内存的因此不存在内存浪费问题。可任意插入和删除数据：在链表中，可以指定删除和添加...
数据结构之链表学习笔记
weixin_43785325的博客
07-05 115
提起链表，我们往往会同时提到数组，先说一下数组，在各种编程语言中都有涉及到，是一种常见的数据结构。 数组是一种线性存储结构，元素类型相同，在创建数组的时候，元素类型就已经被定义。 数组的优点：读取速度快，因为数组的元素读取是用下标来确定的； 数组的缺点：增删速度慢，长度事先被定义，需要连续的内存地址来存放这个数组。 有了对比，那么现在来学习一下链表的特点。 链表 链表是什么呢，和名字很像，就是一个链式的表，每个元素又都是一个节点，是一种离散存储的线性结构，在内存中，节点们离散分配，彼此之间通过指针连接，每个
数据结构笔记——链表
yaoning6768的博客
03-07 236
1、 利用指针实现的线性表。是动态的（dynamic），即能按照需要为表中新的元素分配存储空间。 2、 链表由一系列结点（node）组成。 3、 单链表。Link类：包含一个存储元素值的element域和储存表中下一个指针的next域。 template &amp;lt;typename E&amp;gt; class Link { public: E element; Link *next; Link(c...
数据结构笔记之链表
weixin_43795964的博客
11-25 160
链表是基础的数据结构，是一种线性表，它能够用通过顺序存储和链式存储两种方式。 采用顺序存储的可以建立如下结构体。 将所有的元素存储在数组中，这样建立的链表，链表的存储也比较方便，但是这样的链表缺少灵活性，而且是静态的，不能够任意增大链表的长度，操作起来不方便。 下面介绍链式存储的链表，也是常用的存储方式 建立结构体，结构体中含有指向下一个节点的指针和元素的类型。 下面介绍链表的一些基本操作 首先...
数据结构与算法之链表笔记
qq_42426495的博客
05-31 112
一、概念 链表（linked list）是一种在物理上非连续、非顺序的数据结构，由若干节点（node）所组成。 链表中数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元 素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据 域，另一个是存储下一个结点地址的指针域。（百度百科） 常见的链表包括：单链表、双向链表、循环链表 二、单链表 单向链表的每一个节点又包含两部分，一部分是存放数据的变量data，另一部分是指向下一个节 点的指针n
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值