数据结构--链表（代码实现）

最新推荐文章于 2024-06-06 09:00:00 发布
最新推荐文章于 2024-06-06 09:00:00 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： 笔记 C语言 文章标签： 链表 数据结构 ar
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45689245/article/details/121164483
版权

链表分类

链表分为单向链表(Singly linked lis)、双向链表(Doubly linked list)、循环链表(Circular Linked list)。

 

应用：  1).用于数据数目事先无法确定的情况；
             2).用于数据数在内存中不连续存放的情况；
       组成：   1). 头指针
                     2). 结点(节点)
             2.1  数据域
             2.2  指针域(指向下一个节点)
 2.链表操作：
      2.1 链表创建：
          步骤：1.创建一个结点(申请可以存放一个结点数据的内存空间)
            2.填充结点数据(实际数据，指针)
        3.返回头结点首地址

3 链表插入：
          步骤：1.创建一个结点(申请可以存放一个结点数据的内存空间)
            2.填充结点数据(实际数据，指针)
        3.根据插入算法，将结点链接到链表中。

4 链表删除

单向链表(Singly linked lis)

单向链表是最简单的链表形式。我们将链表中最基本的数据称为节点(node)，每一个节点包含了数据块和指向下一个节点的指针。

#ifndef __LIST_H__
#define __LIST_H__

typedef int DATA;

typedef struct node
{
  DATA data;
  struct node* next;
}Node;

Node* list_create(DATA);
Node* list_addhead(Node*,DATA);
Node* list_addtail(Node*,DATA);
Node* list_addtail_v2(Node*,DATA);
Node* list_delete(Node*,DATA);
void list_show(Node*);
void list_free(Node**);




#endif


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

Node* list_create(DATA data)
{
   Node* p = (Node*)malloc(sizeof(Node));
   if(!p)
   {
      puts("申请内存失败!");
      return NULL;
   }
   p->data = data;
   p->next = NULL;

   return p;
}

Node* list_addhead(Node* head,DATA data)
{
  if(!head)
  {
     return list_create(data);
  }
  
   Node* p = (Node*)malloc(sizeof(Node));
   if(!p)
   {
      puts("申请内存失败!");
      return NULL;
   }
   p->data = data;
   p->next = head;

   head = p;

   return head;
}

Node* list_addtail(Node* head,DATA data)
{
   if(!head)
      return list_create(data);

   Node* p = (Node*)malloc(sizeof(Node));
   if(!p)
   {
      puts("申请内存失败!");
      return head;
   }
   p -> data = data;
   p -> next = NULL;
  
   Node* q = head;
   while(q->next)
   {
      q = q->next;
   }
   q ->next = p;
   return head;
}

Node* list_addtail_v2(Node* head,DATA data)
{
   Node* pNew = (Node*)malloc(sizeof(Node));
   if(!pNew)
   {
      puts("申请内存失败!");
      return head;
   } 
   pNew -> data = data;
   pNew -> next = NULL;

   Node* p = head,*q = NULL;
   while(p)
   {
       q = p;
       p = p ->next;
   }
   if(head)
      q->next = pNew;
   else
      head = pNew;

   return head;
}

Node* list_delete(Node* head,DATA del)
{
   if(!head)
   {
     puts("链表为空!!!");
     return NULL;
   }
   Node* p = head;
   if(head -> data == del)
   {
      head = head->next;
      free(p);
      return head; 
   }
   Node* q = NULL;
   
   while(p)
   {
     if(p -> data == del)
     {
        q->next = p ->next;
        free(p);
        return head;
     }
      q = p;
      p = p->next;
   }
   puts("删除的数据不存在!");
   return head;
}
void list_show(Node* head)
{
   Node* p = head;
   while(p)
   {
      printf("%5d",p->data);
      p = p->next;
   }
   printf("\n");
}
void list_free(Node** head)
{
   Node *p = *head,*q;
  
   while(p)
   {
      q = p;
      p = p->next;
      free(q);
   }
   *head = NULL;
}

#include "list.h"
#include <stdio.h>


int main(void)
{
  int del;
  int a[] = {1,3,5,7,9};
  Node* head = NULL;
  
  head = list_delete(head,7);
  
  register int i = 0;

  for(; i< sizeof a /sizeof a[0]; i++)
  {
      head = list_addtail_v2(head,a[i]);
  }
  list_show(head);
  puts("=============");

  while(1)
  {
     puts("请输入要删除的数据:");
     scanf("%d",&del);
     if(del == -1)
       break;
     head = list_delete(head,del);
          
     list_show(head);
  }

  list_free(&head);
  
  list_show(head);

  return 0;
}

双向链表(Doubly linked list)


顾名思义，双向链表就是有两个方向的链表。同单向链表不同，在双向链表中每一个节点不仅存储指向下一个节点的指针，而且存储指向前一个节点的指针。通过这种方式，能够通过在O(1)时间内通过目的节点直接找到前驱节点，但是同时会增加大量的指针存储空间。

#ifndef __DLIST_H__
#define __DLIST_H__

typedef int DATA;

typedef struct _node
{
  DATA data;
  struct _node *prev;
  struct _node *next;
}Node;

int Dlist_create(Node** head,DATA data);
int Dlist_addhead(Node** head,DATA data);
int Dlist_addtail(Node** head,DATA data);
int Dlist_insert_bypos(Node** head,Node* pos,DATA data);
int Dlist_insert(Node** head,DATA data1,DATA data);

Node* Dlist_find(Node*,DATA);

int Dlist_delete_bypos(Node** head,Node* pos);
int Dlist_delete(Node** head,DATA data);

void Dlist_show(Node*);
void Dlist_free(Node** head);

#endif

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

/**
  * @brief  创建双向链表
  * @param  head: 头指针地址
  * @param  data: 节点数据
  * @retval 成功返回0,失败返回-1
  */
int Dlist_create(Node** head,DATA data)
{
  Node* p = (Node*)malloc(sizeof(Node));

  if(!p)
  {
    puts("创建结点失败!");
    return -1;
  }

  p -> data = data;
  p -> next = NULL;
  p -> prev = NULL;
  *head = p;

  return 0;
}

int Dlist_addhead(Node** head,DATA data)
{
   Node* p = (void*)malloc(sizeof(Node));
   if(!p)
   {
       puts("创建结点失败\n");
       return -1;
   }
   p -> data = data;
   p -> prev = NULL;
   p -> next = *head;

   if(*head)
       (*head)->prev = p;
   *head = p;
   
   return 0;
}


int Dlist_addtail(Node** head,DATA data)
{
   Node* p  = *head,*q = NULL;

   Node* pNew = (void*)malloc(sizeof(Node));
   if(!pNew)
   {
       puts("创建结点失败\n");
       return -1;
   }
   pNew -> data = data;
   pNew -> next = NULL;

   while(p)
   {
      q = p;
      p = p -> next;
   }
   
   pNew -> prev = q;
   if(*head)
       q -> next = pNew;
   else
       *head = pNew;
   return 0;
}

Node* Dlist_find(Node* head,DATA data)
{
  Node* p = head;
  while(p)
  {
     if(p -> data == data)
        return p;
     p = p -> next;
  }
  return NULL;
}

int Dlist_insert_bypos(Node** head,Node* pos,DATA data)
{
   if(*head == NULL)
     return Dlist_create(head,data);
   if(*head == pos)
     return Dlist_addhead(head,data);
   if(!pos)
     return Dlist_addtail(head,data);

   Node* p = (Node*)malloc(sizeof(Node));
   if(!p)
   {
      puts("创建结点失败!");
      return -1;
   }
   p -> data = data;
   p -> prev = pos -> prev;
   p -> next = pos;

   pos -> prev -> next = p;
   pos -> prev = p;

   return 0;
}

int Dlist_insert(Node** head,DATA data1,DATA data2)
{
  Node* pos = Dlist_find(*head,data1);
  return Dlist_insert_bypos(head,pos,data2); 
}

int Dlist_delete_bypos(Node** head,Node* pos)
{
   if((*head == NULL) || !pos)
   {
     puts("链表为空,或位置不存在!");
     return -1;
   } 
   if((pos->prev == NULL) &&(pos->next == NULL))
   {
      *head = NULL;
      free(pos);
      return 0;
   }
   if(pos == *head)
   {
      pos->next->prev = NULL;
      *head = pos->next;
      free(pos);
      return 0;
   }
   if(pos -> next == NULL)
   {
      pos -> prev ->next = NULL;
      free(pos);
      return 0;
   }
   pos->prev->next = pos -> next;
   pos->next->prev = pos -> prev;

   free(pos);
   return 0;
}

int Dlist_delete(Node** head,DATA data)
{
  Node* pos = Dlist_find(*head,data);
  return Dlist_delete_bypos(head,pos);
}

void Dlist_show(Node* head)
{
  Node* p = head;
  
  while(p)
  {
    printf("%6d",p->data);
    p = p -> next;
  }
  printf("\n");
}

void Dlist_free(Node** head)
{
  Node* p = *head,*q = NULL;
  
  while(p)
  {
     q = p;
     p = p -> next;
     free(q);
  }
  *head = NULL;
}


#include "Dlist.h"
#include <stdio.h>


int main(void)
{
  int del;
  int a[] = {1,3,5,7,9};
  Node* head = NULL;

  register int i = 0;

  for(; i< sizeof a /sizeof a[0]; i++)
  {
      if(Dlist_addtail(&head,a[i]) == -1)
      {
         printf("插入数据 %d 失败!\n",a[i]);
      }
  }
  Dlist_show(head);
  puts("=============");


  while(1)
  {
     puts("请输入要[查找/删除]的数据:");
     scanf("%d",&del);
     if(del == -1)
       break;
     //Node* pos = Dlist_find(head,del);
     //Dlist_insert(&head,pos,100);
     if(Dlist_insert(&head,del,888)== -1)
     {
        puts("删除失败!");
        continue;
     }    
     Dlist_show(head);
  }

  Dlist_free(&head);
  
  //list_show(head);
  
   return 0;
}

循环链表(Circular Linked list)

循环链表与双向链表相似，不同的地方在于：在链表的尾部增加一个指向头结点的指针，头结点也增加一个指向尾节点的指针，以及第一个节点指向头节点的指针，从而更方便索引链表元素。

#ifndef __DLIST_H__
#define __DLIST_H__

typedef int DATA;

typedef struct _node
{
  DATA data;
  struct _node *prev;
  struct _node *next;
}Node;

Node* list_init(DATA data);
void list_add_head(Node *new, Node *head);
void list_add_tail(Node *new, Node *head);
void list_show(Node*);

//void list_free(Node** head);

#endif

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

Node* list_init(DATA data)
{
   Node* p = (Node*)malloc(sizeof(Node));
   if(!p)
      return NULL;
   p -> data = data;
   p -> prev = p;
   p -> next = p;
   return p;
}

static void __list_add(Node *new,Node *prev,Node *next)
{
        next->prev = new;
        new->next = next;
        new->prev = prev;
        prev->next =  new;
}

void list_add_head(Node *new, Node *head)
{
        __list_add(new, head, head->next);
}

void list_add_tail(Node *new, Node *head)
{
        __list_add(new, head->prev, head);
}

void list_show(Node* head)
{
  Node* p = head;
  while(p)
  {
     printf("%6d",p->data);
     p = p ->next;
     if(p == head)
      break;
  } 
  printf("\n");
}

#include "dclist.h"
#include <stdio.h>


int main(void)
{
  int del;
  int a[] = {1,3,5,7,9};
  Node* head = list_init(a[0]);

  register int i = 1;

  for(; i< sizeof a /sizeof a[0]; i++)
  {
      Node* new = list_init(a[i]);
      list_add_tail(new,head);
  }
  list_show(head);
  puts("=============");

/*
  while(1)
  {
     puts("请输入要[查找/删除]的数据:");
     scanf("%d",&del);
     if(del == -1)
       break;
     //Node* pos = Dlist_find(head,del);
     //Dlist_insert(&head,pos,100);
     if(Dlist_insert(&head,del,888)== -1)
     {
        puts("删除失败!");
        continue;
     }    
     Dlist_show(head);
  }

  Dlist_free(&head);
*/
  //list_show(head);
  
   return 0;
}

鱼非愚
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-链表的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 链表的部分实现代码（单向链表、双向链表、循环链表、约瑟夫环等），详细介绍参考数据结构--链表的系列博文。链接为：https://blog.csdn.net/songshuai0223/category_9742561.html。
数据结构-单链表的学习及代码实现
09-03
【数据结构-单链表的学习及代码实现】 单链表是一种基本的数据结构，它由一系列节点组成，每个节点包含数据域和一个指向下一个节点的指针。与数组不同，链表中的元素在内存中并不一定是连续存储的，而是通过指针...
数据结构 -- 链表详解
m0_73243771的博客
04-27 2098
链表详解，重点讲解两种常用的链表，看到就是赚到！！！
Java数据结构--双向链表
m0_74808313的博客
04-23 1655
在上一篇中我们学习了单向链表的实现，链表中我们除了单向链表还有双向链表，在这一篇我们将更进一步地了解链表，实现双向链表。
链表详解（附有C语言详细代码）
最新发布
Weirdo的博客
06-06 1875
在C语言中，可以使用结构体来定义链表节点。每个节点包含一个数据域（data）和一个指针域（next），其中指针域指向下一个节点。int data;// 数据域// 指针域} Node;链表作为一种重要的数据结构，具有动态分配、插入和删除操作方便等特点。通过定义节点结构、链表初始化、插入节点、删除节点和遍历链表等基本操作，可以实现链表的基本功能。此外，链表还有查找节点、反转链表、链表排序等扩展操作。链表在实际应用中具有广泛的应用场景，如文件存储、网络路由、哈希表冲突解决和LRU缓存淘汰策略等。
数据结构-链表（含全部实现代码）
qq_45967533的博客
03-12 7311
本篇的内容是对链表的一个介绍，并且会使用C语言实现链表的几个主要接口。 目录链表的概念与结构 链表的概念与结构 概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。 一个链表由n个节点组成，每一个节点都是一个结构体，这个结构体里的一个成员是该节点存储的数据，另一个成员是指向下一个节点的指针。 其结构如下 上图只是一种结构的链表，并不是所有的链表都是这样的结构，在实际中链表的结构非常多样，有以下几种情况：是否带头，单向还是双向，是否循环。共23=8种
【数据结构--静态链表】
qq_61719813的博客
05-05 3229
文章目录前言一、静态链表的定义结构描述代码描述二、静态链表的基本操作初始化打印链表静态链表的插入静态链表的删除三、完整代码及运行截图完整代码如下：运行截图四、闵版（略改） 前言 ​ C语言的指针能十分方便的描述链表，但在一些语言，如Basic、Fortran等早期语言中由于没有指针，链表结构就不能用指针来描述，因此便出现了用数组来代替指针来描述单链表的方法。 一、静态链表的定义 结构描述 ​ 此处用于描述链表的数组由两个数据域组成，data和next。即数组的每个下标都对应一个data和一个next。其中，
【数据结构--双链表】
qq_61719813的博客
05-04 3383
文章目录双向链表双向链表的定义双向链表的存储结构双向链表的初始化双向链表的插入双向链表的删除寻找尾结点正向打印反向打印链表节点的读取测试运行截图完整代码闵版代码（略改）总结 双向链表 双向链表的定义 什么是双向链表？ 双向链表顾名思义，就是链表由单向的链变成了双向链。双向链表(double linked list)是在单链表的每个结点中再设置一个指向其前驱结点的指针域。 非空带头结点的双向链表 双向链表的存储结构 //双链表节点结构体 typedef struct DoubleLinkNode {
数据结构 --- c语言实现双向链表
weixin_60569662的博客
07-07 2618
双向链表主要分为三部分前项指针后项指针数据域一般情况下，创建单一个体，前项指针和后项指针都赋值为空一般采用记录头节点和记录尾节点，再封装的方式写双向链表 再定义一个结构体(链表) 通过记录头节点和尾节点的方式去描述链表 创建节点 把用户的数据变成一个结构体变量 创建链表 描述链表最初的状态 头插法 ①新节点的后项指针指向原来链表的头节点②原来链表的头节点的前项指针指向新节点③把原来的头节点移到新节点的位置 打印链表 可以通过前项指针去做打印，也可以通过后项
数据结构-二叉链表的结构与实现
m0_61789994的博客
05-11 8170
二叉链表是一种特殊的链表，它的每个节点都有两个指针，一个指向左子树，一个指向右子树。这种结构可以用来表示树形结构，如二叉树等。二叉链表是一种常用的数据结构，它可以用于实现二叉树、哈夫曼树、二叉堆、二叉搜索树等算法。二叉链表的结构相对简单，实现起来也比较容易，但是需要注意指针的使用，避免出现空指针和死循环等问题。在实际应用中，我们需要根据具体的需求选择合适的数据结构，以提高算法的效率和性能。
Python中常用的数据结构---链表
qq_43061415的博客
03-09 3353
## Python中常用的数据结构---链表 常用的数据结构有数组、链表(一对一)、栈和队列、哈希表、树(一对多)、图(多对多)等结构。 在本目录下我们将讲解，通过python语言实现常用的数据结构。 #### 2.链表 2.1链表的结构 链表（linked list）是一种在物理上非连续、非顺序的数据结构，由若干节点（node）所组成。 （1）单向链表的每一个节点又包含两部分，一部分是存放数据的变量data，另一部分是指向下一节点的指针next。 表示方式如下：
java数据结构-链表详解
m0_63526467的博客
05-04 4072
文章目录1.数据结构-链表详解1.1单链表1.1.1单链表节点的尾部添加1.1.2单链表节点的自动排序添加1.1.3单链表节点的修改1.1.4单链表节点的删除1.2单链表面试题1.2.1单链表的有效节点个数1.2.2单链表倒数第k个结点1.2.3单链表反转1.2.4单链表逆序打印1.3双向链表1.3.1双向链表介绍1.3.2双向链表增删改查1.4单向环形链表1.4.1约瑟夫（Josephu）环问题 1.数据结构-链表详解 链表可分为三类： 单链表 双向链表 循环列表 下面具体分析三个链表的应用。 1.1
C++数据结构--双向链表
海到无边天作岸 山登绝顶我为峰
04-07 2204
测试代码 #include <iostream> #include <iomanip> using namespace std; template <class DataType> struct DulNode { DataType data; DulNode <DataType>*prior,*next; }; template <cla...
链表_数据结构--链表_
10-01
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。...通过分析和实现这些代码，可以提升对数据结构和算法的理解，对于提升编程技能和解决复杂问题的能力非常有帮助。
数据结构-链表(LingkedList)介绍和Java示例代码
07-01
链表是一种重要的线性数据结构，它与数组相比具有独特的特性和优势。链表由一系列节点构成，每个节点包含两部分：数据元素和指向下一个节点的引用。这种结构允许链表在内存中不连续分布，提供了动态扩展和收缩的能力...
数据结构链表：单链表的代码实现
03-20
本文通过数据结构教程的方法利用C++语言写了单链表的各项功能 功能包括 1.链表的初始化 2.链表的查找和判断是否为空表 3.插入 4.取值 5.插入（尾插法） 6.链表的输出 7.//删除指定元素 8.//链表的释放 其中有着详细...
编译出错总结
cat_eat_fish
10-21 8463
一、类型匹配问题： 1、incompatible types in assignment of ‘char*’ to ‘char [64]’ 可以使用strcpy();解决。 2、error: assigning to an array from an initializer list //不能对数组赋值，只能对数组元素初始化或赋值。 3、[Error] ‘f’ was not declared in this scope f 没有进行声明 ...
解析复杂的json数组嵌套
cat_eat_fish
07-30 7440
[ { "chanNameList": [ { "channelName": "通道1", "enable": 1, "perX": 0, "perY": 0, "rgbaBG": "#00000000", "rgbaFont": "#00000000" } ], "channel": 1, "ip": "192.168.121.13", "status": 1, "streamInfo": [ { "IFrameInterval": 50, "aBitrate": 6.
QT中同界面添加多个组件窗口
cat_eat_fish
08-03 6238
1、打开Qt Creator，新建一个Qt Widgets Application项目，添加控件Stacked Widget和PushButton，然后再添加3个子窗口类 子窗口类可有自己任意定义，创建好后将头文件引入主窗口类，并定义子类的对象为主类私有变量，方便成员函数访问。 MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent) , ui(new Ui::MainWindow) { u.
链表的输出和实现-数据结构实践
链表是一种常用的数据结构，它可以用来存储大量的数据元素，並且可以实现高效的数据操作。下面我们将详细介绍链表的输出和相关知识点。 一、链表的输出 链表的输出是指将链表中的数据元素输出到屏幕上。通常，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值