链表的代码实现及其讲解

最新推荐文章于 2024-07-26 11:13:55 发布
最新推荐文章于 2024-07-26 11:13:55 发布
阅读量1.7k 收藏 11
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_37963760/article/details/76571566
版权 
第一部分是整体代码，第二部分我会分开进行分析：
第一部分：

#include<stdio.h>
#include<iostream>
#include<assert.h>

typedef int Datatype;

typedef struct LinkList
{
 Datatype data;
 struct LinkList* next;
}List, *pList;

pList linshi(Datatype d)//创建一个临时变量
{
 pList tmp = NULL;
 tmp = (pList)malloc(sizeof(List));
 if (tmp == NULL)
 {
  perror("malloc()");
  exit(EXIT_FAILURE);
 }
 tmp->data = d;
 tmp->next = NULL;
}

void InintLinkList(pList *ppList)//初始化链表
{
 assert(ppList);
 *ppList = NULL;
}

void PushFront(pList *pplist, Datatype d)//从前插入节点
{
 assert(pplist);
 //空链表
 if (*pplist == NULL)
 {
  pList tmp = linshi(d);
  *pplist = tmp;
 }
 //非空链表
 else
 {
  pList cur = *pplist;
  pList tmp = linshi(d);
  tmp->next = *pplist;
  *pplist = tmp;
 }
}
void PopFront(pList *pplist)//从前删除节点
{
 assert(pplist);
 //非空链表
 if (*pplist != NULL)
 {
  pList cur = *pplist;
  *pplist = cur->next;
  free(cur);
 }
 //空链表
 else
 {
  return;
 }
}

void PushBack(pList *pplist, Datatype d)//从后插入节点
{
 assert(pplist);

 //空链表
 if (*pplist == NULL)
 {
  pList tmp = linshi(d);
  *pplist = tmp;
  return;
 }

 //非空链表
 pList cur = *pplist;
 pList tmp = linshi(d);
 while (cur->next != NULL)
 {
  cur = cur->next;
 }
 cur->next = tmp;
}
void PopBack(pList *pplist)//从后删除节点
{
 assert(pplist);
 //空链表
 if (*pplist == NULL)
 {
  return;
 }
 //非空链表
 else
 {
  pList cur = *pplist;
  cur = cur->next;
  if (cur->next == NULL)
  {
   *pplist = NULL;
   free(cur);
  }
  else
  {
   pList del = *pplist;
   while (cur->next != NULL)
   {
    del = cur;
    cur = cur->next;
   }
   del->next = NULL;
   free(cur);
  }

 }
}

void Display(pList pplist)//打印链表
{
 pList cur = pplist;
 while (cur != NULL)
 {
  printf("%d --> ", cur->data);
  cur = cur->next;
 }
 printf("over\n");
}

pList Find(pList pplist, Datatype d)//查询相应数据
{
 if (pplist == NULL)
 {
  return NULL;
 }
 pList cur = pplist;
 while (cur != NULL)
 {
  if (cur->data == d)
  {
   return cur;
  }
  cur = cur->next;
 }
 return cur;
}

void Remove(pList *pplist, Datatype d)//删除
{
 assert(pplist);
 if (*pplist == NULL)
 {
  return;
 }
 else
 {
  pList cur = *pplist;
  while (Find(*pplist, d) != NULL && cur != NULL)
  {
   if (cur->data == d)
   {
    pList tmp = cur->next;
    cur->data = cur->next->data;
    cur->next = cur->next->next;
    free(tmp);
    return;
   }
   cur = cur->next;
  }
 }
}
void RemoveAll(pList *pplist, Datatype d)//删除所有
{
 assert(pplist);
 if (*pplist == NULL)
 {
  return;
 }
 else
 {
  pList cur = *pplist;
  while (Find(*pplist, d) != NULL && cur != NULL)
  {
   if (cur->data == d)
   {
    pList tmp = cur->next;
    cur->data = cur->next->data;
    cur->next = cur->next->next;
    free(tmp);
   }
   cur = cur->next;
  }
 }
}

void Insert(pList *pplist, int pos, Datatype d)//指定节点插入
{
 assert(pplist);
 //空链表
 if (*pplist == NULL)
 {
  pList tmp = linshi(d);
  *pplist = tmp;
  return;
 }
 //非空链表
 else
 {
  pList cur = *pplist;
  pos = pos - 1;
  pList tmp = linshi(d);
  while (pos--&&cur->next != NULL)
  {
   cur = cur->next;
  }
  if (pos > 0)
  {
   cur->next = tmp;
   tmp->data = d;
   tmp->next = NULL;
   return;
  }
  tmp->data = cur->data;
  cur->data = d;
  tmp->next = cur->next;
  cur->next = tmp;
 }
}
void Insert_Remove(pList *pplist, int pos)//指定节点删除
{
 assert(pplist);
 //空链表
 if (*pplist == NULL)
 {
  return;
 }
 //非空链表
 else
 {
  pList cur = *pplist;
  pList tmp = *pplist;
  pos = pos - 1;
  while (pos--&&cur->next != NULL)
  {
   cur = cur->next;
  }
  if (pos != 0)
  {
   pList del = *pplist;
   while (tmp->next != NULL)
   {
    del = tmp;
    tmp = tmp->next;
   }
   del->next = NULL;
   free(cur);
   return;
  }
  tmp = cur->next;
  cur->data = cur->next->data;
  cur->next = cur->next->next;
  free(tmp);
 }
}

pList Reverse(pList *pplist)//逆序
{
 assert(pplist);
 pList cur = *pplist;
 pList head = cur->next;
 pList newhead = NULL;
 head = cur->next;
 cur->next = NULL;
 newhead = cur;
 while (head != NULL)
 {
  cur = head;
  head = cur->next;
  cur->next = newhead;
  newhead = cur;
 }
 return newhead;
}
void Sort(pList *pplist)//排序  从小到大
{
 assert(pplist);
 pList cur = *pplist;
 int count = 0;
 int i, j;
 while (cur != NULL)
 {
  count++;
  cur = cur->next;
 }
 cur = *pplist;
 for (i = 0; i < count - 1; i++)
 {
  cur = *pplist;
  for (j = 0; j < count - 2 - i; j++)
  {
   if (cur->data > cur->next->data)
   {
    Datatype tmp;
    tmp = cur->data;
    cur->data = cur->next->data;
    cur->next->data = tmp;
   }
   cur = cur->next;
  }
 }

}

int main()
{
 pList head;
 InintLinkList(&head);

 /*PushFront(&head, 1);
 PushFront(&head, 2);
 PushFront(&head, 3);
 PushFront(&head, 4);
 PushFront(&head, 5);
 PushFront(&head, 6);
 Display(head);*/
 //PopFront(&head);
 //PopFront(&head);
 //PopFront(&head);
 //Display(head);

 //PushBack(&head, 1);
 //PushBack(&head, 2);
 //PushBack(&head, 7);
 //PushBack(&head, 4);
 //PushBack(&head, 7);
 //PushBack(&head, 6);
 //PushBack(&head, 7);
 //PushBack(&head, 8);
 //PushBack(&head, 9);
 //Display(head);
 //PopBack(&head);
 //PopBack(&head);
 //PopBack(&head);

 //pList ret = Find(head, 11);
 //if (ret == NULL)
 //{
 // printf("没找到！\n");
 //}
 //else
 //{
 // printf("找到了！\n");
 //}
 //Remove(&head, 7);
 //RemoveAll(&head, 7);
 //Insert(&head, 2, 11);
 //Insert_Remove(&head, 13);
 /*pList tmp = Reverse(&head);
 Display(tmp);*/
 //Sort(&head);
 Display(head);

 system("pause");
 return 0;
}


第二部分：

#include<stdio.h>
#include<assert.h>

（1）引用头文件，因为文章里面用到了断言（assert），所以需要引用assert.h头文件，stdio.h包含了c语言里面一些基本的函数，例如printf  scanf函数等等。

typedef int Datatype;

（2）类型重命名，因为你不知道要创建一个什么类型的链表，所以最好在开头进行一个类型重命名，这样会扩大适用性。

typedef struct LinkList
{
 Datatype data;
 struct LinkList* next;
}List, *pList;

（3）创建一个结构体，作为链表中每个节点的结构类型，并进行了结构体的重命名，结构体为List，结构体指针为pList。

pList linshi(Datatype d)//创建一个临时变量
{
 pList tmp = NULL;
 tmp = (pList)malloc(sizeof(List));
 if (tmp == NULL)
 {
  perror("malloc()");
  exit(EXIT_FAILURE);
 }
 tmp->data = d;
 tmp->next = NULL;
}

（4）因为在函数中会多次应用这段代码，所以我把这段代码单独拿出来分装成一个函数，这样做可以减少代码的长度。

void InintLinkList(pList *ppList)//初始化链表
{
 assert(ppList);
 *ppList = NULL;
}

（5）初始化链表，创建一个新的链表时要进行初始化操作，在后面调用函数时会判断该链表是否为空链表，如果不经心初始化的话，在哦岸段是否为空链表的时候容易出错。

void PushFront(pList *pplist, Datatype d)//从前插入节点
{
 assert(pplist);
 //空链表
 if (*pplist == NULL)
 {
  pList tmp = linshi(d);
  *pplist = tmp;
 }
 //非空链表
 else
 {
  pList cur = *pplist;
  pList tmp = linshi(d);
  tmp->next = *pplist;
  *pplist = tmp;
 }
}

（6）在前面插入节点时，注意要注意保存第一个节点的地址，先把第一个节点的地址赋给新添加节点的next指针，然后head指针再指向新节点，这样就完成了一个节点的添加，下面是图片示意图：
void PopFront(pList *pplist)//从前删除节点
{
 assert(pplist);
 //非空链表
 if (*pplist != NULL)
 {
  pList cur = *pplist;
  *pplist = cur->next;
  free(cur);
 }
 //空链表
 else
 {
  return;
 }
}

（7）从前删除节点只需要用head指针指向第二个节点然后在释放掉第一个节点的空间，因为是动态开辟出来的空间，所以在不用的时候要记住释放掉该空间。

void PushBack(pList *pplist, Datatype d)//从后插入节点
{
 assert(pplist);

 //空链表
 if (*pplist == NULL)
 {
  pList tmp = linshi(d);
  *pplist = tmp;
  return;
 }

 //非空链表
 pList cur = *pplist;
 pList tmp = linshi(d);
 while (cur->next != NULL)
 {
  cur = cur->next;
 }
 cur->next = tmp;
}

（8）在后面添加节点只需要添加一个指针，让他运行到最后一个节点处，然后让其next指针指向该新节点就完成了。
void PopBack(pList *pplist)//从后删除节点
{
 assert(pplist);
 //空链表
 if (*pplist == NULL)
 {
  return;
 }
 //非空链表
 else
 {
  pList cur = *pplist;
  cur = cur->next;
  if (cur->next == NULL)
  {
   *pplist = NULL;
   free(cur);
  }
  else
  {
   pList del = *pplist;
   while (cur->next != NULL)
   {
    del = cur;
    cur = cur->next;
   }
   del->next = NULL;
   free(cur);
  }

 }
}

（9）创造两个指针分别指向前一个结点和后一个节点，分别往后运行，知道前面的指针找到最后一个节点为止，此时后面的指针指向了倒数第二个节点，此时只需要把倒数第二个节点denext指针制成空指针就好了，最后不要忘记释放最后一个节点的空间。

void Display(pList pplist)//打印链表
{
 pList cur = pplist;
 while (cur != NULL)
 {
  printf("%d --> ", cur->data);
  cur = cur->next;
 }
 printf("over\n");
}

（10）只需要创建一个指针然后从前往后遍历就好，依次打印出每个节点的数据就好。

pList Find(pList pplist, Datatype d)//查询相应数据
{
 if (pplist == NULL)
 {
  return NULL;
 }
 pList cur = pplist;
 while (cur != NULL)
 {
  if (cur->data == d)
  {
   return cur;
  }
  cur = cur->next;
 }
 return cur;
}

（11）创造一个指针从前往后遍历每次与需要查找的数据进行对比，是否相同，若相同则返回相应的地址，若不相同则返回空指针。

void Remove(pList *pplist, Datatype d)//删除
{
 assert(pplist);
 if (*pplist == NULL)
 {
  return;
 }
 else
 {
  pList cur = *pplist;
  while (Find(*pplist, d) != NULL && cur != NULL)
  {
   if (cur->data == d)
   {
    pList tmp = cur->next;
    cur->data = cur->next->data;
    cur->next = cur->next->next;
    free(tmp);
    return;
   }
   cur = cur->next;
  }
 }
}

（12）应用查找函数判断是否有要删除的数据，如果有就删除相应的节点，有两种方法：

第一种：把该节点的下一个节点的内容赋给该节点，然后删除下一个节点，

第二种：跟删除最后面的节点有点相似，也是用两个指针从头往后遍历，一前一后，然后找到该节点把该节点的上一个节点的next指针指向该节点的下一个节点。再释放掉该节点就好。
void RemoveAll(pList *pplist, Datatype d)//删除所有
{
 assert(pplist);
 if (*pplist == NULL)
 {
  return;
 }
 else
 {
  pList cur = *pplist;
  while (Find(*pplist, d) != NULL && cur != NULL)
  {
   if (cur->data == d)
   {
    pList tmp = cur->next;
    cur->data = cur->next->data;
    cur->next = cur->next->next;
    free(tmp);
   }
   cur = cur->next;
  }
 }
}

（13）删除所有就是删除掉一个数据后不停止，继续重新查找。直到查找不出来后停止。

void Insert(pList *pplist, int pos, Datatype d)//指定节点插入
{
 assert(pplist);
 //空链表
 if (*pplist == NULL)
 {
  pList tmp = linshi(d);
  *pplist = tmp;
  return;
 }
 //非空链表
 else
 {
  pList cur = *pplist;
  pos = pos - 1;
  pList tmp = linshi(d);
  while (pos--&&cur->next != NULL)
  {
   cur = cur->next;
  }
  if (pos > 0)
  {
   cur->next = tmp;
   tmp->data = d;
   tmp->next = NULL;
   return;
  }
  tmp->data = cur->data;
  cur->data = d;
  tmp->next = cur->next;
  cur->next = tmp;
 }
}

（14）指定节点插入跟我下一篇博客要说的无头非尾链表插入有着相似的原理，这个也有两种方法求解：

第一种：用两个指针一前一后往后遍历，直到前面的指针找到要插入的节点，然后创造一个新的节点暂时命名为tmp，让tmp节点的next指针指向前面的指针所指向的节点，然后再让后面zhizhendenext指针指向tmp节点，最后再对tmp的data进行赋值就完成节点插入了。

第二种：定义一个指针让其指向需要插入的节点，然后创造一个新的节点暂时命名为tmp，先让tmp节点的next指针指向该节点的下一个节点，然后让该节点的next指针指向tmp节点，成功添加了一个节点后就是进行值交换，创造一个临时变量temp进行值交换就好。
void Insert_Remove(pList *pplist, int pos)//指定节点删除
{
 assert(pplist);
 //空链表
 if (*pplist == NULL)
 {
  return;
 }
 //非空链表
 else
 {
  pList cur = *pplist;
  pList tmp = *pplist;
  pos = pos - 1;
  while (pos--&&cur->next != NULL)
  {
   cur = cur->next;
  }
  if (pos != 0)
  {
   pList del = *pplist;
   while (tmp->next != NULL)
   {
    del = tmp;
    tmp = tmp->next;
   }
   del->next = NULL;
   free(cur);
   return;
  }
  tmp = cur->next;
  cur->data = cur->next->data;
  cur->next = cur->next->next;
  free(tmp);
 }
}

（15）代码思想：用两个指针一前一后往后遍历，直到前面的指针找到要插入的节点，然后用后面指针所指向节点的next指针指向前一个指针所指向节点的后一个节点。然后free掉前一个指针所指向的空间。

pList Reverse(pList *pplist)//逆序
{
 assert(pplist);
 pList cur = *pplist;
 pList head = cur->next;
 pList newhead = NULL;
 head = cur->next;
 cur->next = NULL;
 newhead = cur;
 while (head != NULL)
 {
  cur = head;
  head = cur->next;
  cur->next = newhead;
  newhead = cur;
 }
 return newhead;
}

（16）节点跟数组不同，不能从后往前走，所以只能把第一个拿出来，然后从第二个开始依次拿出来用头插的方法依次插入到新链表的最开始，最后返回新联标的头地址就好。
void Sort(pList *pplist)//排序  从小到大
{
 assert(pplist);
 pList cur = *pplist;
 int count = 0;
 int i, j;
 while (cur != NULL)
 {
  count++;
  cur = cur->next;
 }
 cur = *pplist;
 for (i = 0; i < count - 1; i++)
 {
  cur = *pplist;
  for (j = 0; j < count - 2 - i; j++)
  {
   if (cur->data > cur->next->data)
   {
    Datatype tmp;
    tmp = cur->data;
    cur->data = cur->next->data;
    cur->next->data = tmp;
   }
   cur = cur->next;
  }
 }

}

（17）跟冒泡排序，或者选择法排序没有什么区别，只需要最开始的时候计算出来一共有多少个节点就好，只不过现在交换的不是整个节点而是该节点的data值。

int main()
{
 pList head;
 InintLinkList(&head);

 /*PushFront(&head, 1);
 PushFront(&head, 2);
 PushFront(&head, 3);
 PushFront(&head, 4);
 PushFront(&head, 5);
 PushFront(&head, 6);
 Display(head);*/
 //PopFront(&head);
 //PopFront(&head);
 //PopFront(&head);
 //Display(head);

 //PushBack(&head, 1);
 //PushBack(&head, 2);
 //PushBack(&head, 7);
 //PushBack(&head, 4);
 //PushBack(&head, 7);
 //PushBack(&head, 6);
 //PushBack(&head, 7);
 //PushBack(&head, 8);
 //PushBack(&head, 9);
 //Display(head);
 //PopBack(&head);
 //PopBack(&head);
 //PopBack(&head);

 //pList ret = Find(head, 11);
 //if (ret == NULL)
 //{
 // printf("没找到！\n");
 //}
 //else
 //{
 // printf("找到了！\n");
 //}
 //Remove(&head, 7);
 //RemoveAll(&head, 7);
 //Insert(&head, 2, 11);
 //Insert_Remove(&head, 13);
 /*pList tmp = Reverse(&head);
 Display(tmp);*/
 //Sort(&head);
 Display(head);

 system("pause");
 return 0;
}

以上就是我对该代码一点解释，若有看不懂的地方可在下方的评论处写下不懂的地方，我会及时作出回复的，或者你认为有什么地方可以改进，也希望可以提出宝贵的建议。
谢谢！


LYF0108
关注
链表的代码实现
weixin_55438199的博客
07-08 275
双向链表
链表c代码实现
10-22
该代码实现了线性表的链式存储，包括创建线性表、删除线性表、清空线性表、插入元素、删除元素等API函数
【数据结构】手把手教你单链表（c语言）（附源码）
2301_80955819的博客
07-26 1376
单链表的概念、单链表的结构定义、增删查改等功能实现
链表的实现--代码演示
我可能只是个小白
02-25 403
# 节点类，链表节点类分为data与next域 class Node: def __init__(self,data): self.data = data self.next = None # 单链表头节点 class SingleLinkList: def __init__(self): self._head = None ...
数据结构-链表（含全部实现代码）
qq_45967533的博客
03-12 7947
本篇的内容是对链表的一个介绍，并且会使用C语言实现链表的几个主要接口。 目录链表的概念与结构 链表的概念与结构 概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。 一个链表由n个节点组成，每一个节点都是一个结构体，这个结构体里的一个成员是该节点存储的数据，另一个成员是指向下一个节点的指针。 其结构如下 上图只是一种结构的链表，并不是所有的链表都是这样的结构，在实际中链表的结构非常多样，有以下几种情况：是否带头，单向还是双向，是否循环。共23=8种
链表实现代码
yzc的博客
12-11 503
链表代码
邻接链表法实现图C代码
02-27
本文将详细讲解如何使用邻接链表法来实现图，并介绍上述描述中的各项操作。 1. **创建图**：创建图通常涉及到定义节点（Vertex）和边（Edge）的数据结构。节点可以存储一个标识符（如整数或字符串），而边则存储...
《代码随想录》链表算法详解及实现
最新发布
09-17
文章首先讲解了什么是链表及其各种类型的特性，比如循环链表用于约瑟夫环问题等，并探讨了如何使用不同的方式实现链表节点定义和删除。此外，《代码随想录》系列文章进一步剖析了具体的LeetCode题目，包括链表常见...
cpp代码-链表头文件
07-16
总结来说，"cpp代码-链表头文件"涉及的是C++中链表数据结构的实现，包括链表节点的定义和各种链表操作。`main.cpp`文件可能是这些操作的实例化，而`README.txt`则提供了关于如何理解和使用这些代码的指导。学习和...
python数据结构链表之单向链表(实例讲解)
09-21
本文将深入探讨单向链表这一概念，并通过实例讲解如何在Python中实现单向链表。 单向链表，也称为单链表，是一种线性数据结构，其特点是每个节点包含两部分：元素域（用于存储数据）和链接域（用于指向链表中的下一...
单链表代码
02-01
根据C语言国嵌嵌入式数据结构教学视频整理而成，内含详细的注释，亲测可用。
链表代码（完整）
热门推荐
ShawnWang1994的博客
08-19 1万+
#include<stdio.h> #include<malloc.h> #include<stdbool.h> //定义链表 typedef struct ListNode{ int val; struct ListNode* next; }ListNode; //链表初始化 ListNode* CreateList() { ListNode* Hea...
数据结构--链表（代码实现）
cat_eat_fish
11-23 1266
链表分类 链表分为单向链表(Singly linked lis)、双向链表(Doubly linked list)、循环链表(Circular Linked list)。 应用： 1).用于数据数目事先无法确定的情况； 2).用于数据数在内存中不连续存放的情况； 组成： 1). 头指针 2). 结点(节点) 2.1 数据域 2.2 指针域...
单链表的插入、删除、头插法、尾插法、倒置、合并、查找、阿瑟夫环
m0_57124079的博客
04-16 717
单链表的插入、删除、头插法、尾插法、倒置、合并、查找、阿瑟夫环 详细代码如下 #include "stdio.h" #include "malloc.h" #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 #define TRUE 1 #define FALSE 0 #define List_Init_Size
相关链表的代码
z6_6z的博客
09-13 258
本代码是对链表的建立，及删除，插入，寻找，输出的函数表达 #include #include using namespace std; typedef struct node{ int date; struct node *next; }node;//建立节点 node *creatline(node *head,int n) { node *p; cout<<"请输入对应链表的数值"
C++：链表代码
weixin_30539835的博客
04-21 65
（1）单向链表 //单向链表 #include<iostream.h> #include<iomanip.h> class CNode //节点类 { public: CNode *m_pNext; int m_Data; CNode():m_pNext(NULL){} }; class CList //链表类 {...
链表代码详解
小程的博客
04-10 278
链表
C++实现动态链表二叉树及其遍历教程
实验主要分为两个部分：理论讲解和代码实现。 一、教学内容 1. 动态链表存储的二叉树基础：首先介绍如何使用C++实现动态链表来存储二叉树，这涉及到节点的定义、结构以及如何通过指针进行链接。 2. 二叉树遍历：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值