链表转载：https://blog.csdn.net/laifengyuan1/article/details/98345444-CSDN博客

二、单向链表与双向链表的区别

三、单链表的实现

四、双向(循环)链表的实现

一、链表
链表所需要的功能:

初始化
创建新节点
插入
删除
查询
链表的销毁(释放包括头结点在内的空间)
链表的清空（释放除了头结点以外的空间）
链表的优缺点：

优点：链表不需要初始化容量，可以任意加减元素，并且添加与删除元素十分快捷，只需要改变指针域指向的内容即可，内存利用率高，
缺点：查找元素，需要通过遍历链表来查找，十分耗时
适用于：需要频繁添加或者删除操作的场景
二、单向链表与双向链表的区别
单向链表与双向（循环）链表的区别：

在存储空间方面：单链表需要的存储空间比双向链表的要少，因为双向链表不仅保存有指向下一个节点的指针，还保存有指向上一个节点的指针，需要较大的空间来存储双向链表的指针域。
在处理时间方面：双向链表的插入与删除操作比单链表的时间要快很多。在最末尾插入的时候，单链表需要找到需要插入位置的前一个节点，需要遍历整个链表，时间复杂度为O（n），而双向链表只需要head->tail,就可以得到最后一个节点的位置，然后就可以进行插入操作，时间复杂度为O（1）。在删除操作方面，单链表需要遍历到需要删除的节点的前一个节点，双向链表需要遍历到需要删除的节点，时间复杂度同为O(n)。
一个提高单链表尾部插入效率的小方法：

定义一个指针tail，专门指向单链表的最末尾。如图所示

一、链表链表所需要的功能:

注意：在处理单链表的插入的时候，优先处理新节点！

链表的定义
/*结构体*/
typedef int datatype;
typedef struct node
{
   datatype data;
   struct node *next;

}node,*list;

/*单链表的尾指针*/
struct node *tail;
链表的初始化
/*
   创建头节点
*/
list initNode()
{
   list head = malloc(sizeof(node));
   if(head != NULL)
   {
       head->next = NULL;
   }

   tail = head;//尾指针指向头结点

   return head;
}
创建新的节点
/*
   创建新节点
*/
list newNode(datatype n)
{
   list new = malloc(sizeof(node));
   if(new != NULL)
   {
       new->data = n;
       new->next = NULL;
   }

   return new;
}
尾插法：插入节点
/*
   尾插法，添加节点（包含尾指针）
   插入需要注意：优先处理新节点、不先动旧的链表
*/
bool insertNode_tail(list new)
{
   /*判断新的节点是否为空*/
   if (new == NULL)
   {
       printf("new point to NULL\n");
       return false;
   }

   new->next = NULL;
   tail->next = new;
   tail = new;//tail指向最后一个节点

   return true;
}

/*
不含有尾指针
*/
bool insertNode_tail(list new,list head)
{
   /*判断新的节点是否为空*/
   if (new == NULL)
   {
       printf("new point to NULL\n");
       return false;
   }

list p = head;
   while(p->next != NULL)//搜索到最后的节点
   {
       p = p->next;
   }

new->next = NULL;//优先处理新节点
p->next = new;

   return true;
}
删除节点
/*
   删除节点：输入对应数字的负数形式，则会删除对应数字
*/
bool delNode(datatype data, list head)
{
   //数据处理
   data = -data;

   list p = head;
   while(p->next != NULL)//找到要删除的节点的前一个节点
   {
       if(p->next->data == data)break;
       p = p->next;
   }

   list del_p = p->next;//要删除的节点
   p->next = del_p->next;
   free(del_p);//释放空间

   tail = head;//将tail指针指向最末尾
   while(tail->next != NULL)
   {
       tail = tail->next;
   }

   return true;
}
查询链表
/*
   查询节点
*/
void showNode(list head)
{
   list p = head->next;
   do
   {
       printf("%d\t", p->data);
       p = p->next;
   }while(p != NULL);

   printf("\n");
}
销毁与清空链表
销毁链表：释放包括头节点的所有空间
清空链表：释放除了头节点的其他节点空间
/*
   销毁整个链表
*/
void destoryAllNode(list head)
{
   list p = head;
   list next_p = NULL;
   while(p != NULL)
   {
       next_p = p->next;//存储下一个节点指针
       free(p);//释放当前节点
       p = next_p;//指向销毁后的下一个节点
   }
}

/*
   清空链表
*/
void clearNode(list head)
{
   list p = head->next;//p指向第一个节点
   list next_p = NULL;
   while(p != NULL)
   {
       next_p = p->next;
       free(p);
       p = next_p;
   }
}
四、双向(循环)链表的实现
双向链表的定义
/*结构体*/
typedef int datatype;
typedef struct node
{
   datatype data;
   struct node *next, *pre;

}node,*list;
双向链表的初始化
/*
   创建头节点
*/
list initNode()
{
   list head = malloc(sizeof(node));
   if(head != NULL)
   {
       head->next = head;
       head->pre = head;
   }

   return head;
}
创建新节点
/*
   创建新节点
*/
list newNode(datatype n)
{
   list new = malloc(sizeof(node));
   if(new != NULL)
   {
       new->data = n;
       new->next = NULL;
       new->pre = NULL;
   }

   return new;
}
尾插法：插入节点
/*
   尾插法，添加节点
   插入需要注意：优先处理新节点、不先动旧的链表
*/
bool insertNode_weicha(list new, list head)
{
   /*判断新的节点是否为空*/
   if (new == NULL)
   {
       printf("new point to NULL\n");
       return false;
   }

   //优先处理新的节点
   new->pre = head->pre;//head->pre 为最后一个节点
   new->next = head;
   head->pre->next = new;//倒数第二个节点指向新的节点
   head->pre = new;//此时new为最后一个

   return true;
}
删除节点
/*
   删除节点：输入对应数字的负数形式，则会删除对应数字
*/
bool delNode(datatype data, list head)
{
   //数据处理
   data = -data;

   list p = head->next;//p为第一个节点
   while(p->next != head)
   {
       if(p->data == data)break;//p指向要删除的节点
       p = p->next;
   }

   p->next->pre = p->pre;
   p->pre->next = p->next;
   p->pre = NULL;
   p->next = NULL;

   free(p);//释放空间
   return true;
}
查询节点
/*
   查询节点
*/
void showNode(list head)
{
   list p = head->next;//p指向第一个节点
   do
   {
       printf("%d\t", p->data);
       p = p->next;
   }while(p != head);

   printf("\n");
}
销毁与清空链表
/*
   销毁整个链表
*/
void destoryAllNode(list head)
{
   list p = head->next;
   list next_p = NULL;
   while(p != head)
   {
       next_p = p->next;//存储下一个节点指针
       free(p);//释放当前节点
       p = next_p;//指向销毁后的下一个节点
   }

   free(head);
}

/*
   清空链表
*/
void clearNode(list head)
{
   list p = head->next;
   list next_p = NULL;
   while(p != head)
   {
       next_p = p->next;//存储下一个节点指针
       free(p);
       p = next_p;
   }
}

————————————————
版权声明：本文为CSDN博主「不吃鱼的猫丿」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/laifengyuan1/article/details/98345444