单链表、双向链表、循环链表

最新推荐文章于 2024-04-20 21:28:50 发布
最新推荐文章于 2024-04-20 21:28:50 发布
阅读量7.3k 收藏 63
点赞数 17
分类专栏： 数据结构与算法之美学习笔记 文章标签： 数据结构 单向链表 双向链表 循环链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hyt1152860391/article/details/97367313
版权

文章目录

常见链表

学习三种常见的链表结构，他们分别是：单链表、双向链表和循环链表。

单链表

单链表有两个较特殊节点，头结点和尾节点。头结点用来记录链表的基地址，可以用来遍历整条链表。尾结点的指针不是指向下一个节点而是指向一个空地址NULL，表示链表上的最后一个节点。

和数组一样，链表也支持数据的查找、插入和删除操作。但相对于数据的插入删除需要做大量的搬移操作，链表的插入，删除的时间复杂度为O(1)。但是链表想要随机访问第k个元素，就没有数组高效，随机访问数据的时间复杂度为O(n)。单向链表的简单实现代码如下：

link_list.h

/*
 *****************************************************************************
 *
 * File:       linke_list.h
 *
 * Description: Single link list header file
 *
 *
 * History:
 *    Created:  Apri, 2019
 *
 * Copyright (c) 2019 
 * All rights reserved.
 *
 ****************************************************************************/
 #ifndef LINK_LIST_
 #define LINK_LIST_
 
 
 typedef struct _node{
	 struct _node *next;
	 int date;
 }node, *list;

list init_single_link_list();
int insert_to_link_list_head(list list, int date);
int insert_to_link_list_tail(list list, int date);
void show_single_link_list (list head);
void delete_from_link_tail(list list_);
#endif

link_list.c

/*
 *****************************************************************************
 *
 * File:        link_list.c
 *
 * Description: Single link list file
 *
 *
 * History:
 *    Created:  Apri, 2019
 *
 * Copyright (c) 2019 
 * All rights reserved.
 *
 ****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include "link_list.h"

 
list init_single_link_list()
{
	list link_list = NULL;
	
	link_list = (list)malloc(sizeof(list));
	if(NULL == link_list){
		printf("malloc failed !!\n");
		exit(1);
	}
	link_list->next = NULL;
	return link_list;
}

/*
  insert a node to single link list
  头插法
*/
int insert_to_link_list_head(list list_, int date)
{
	list p = NULL;
        
        if (NULL == list_) {
           printf("list is NULL ...\n");
           exit(1);
        }	
	p = (list)malloc(sizeof(list));
	if(p == NULL) {
		printf("malloc failed \n");
		exit(1);
	}
	p->date = date;
	
	p->next = list_->next;
	list_->next = p;
	
	return 1;
}
/*
 * 尾插法实现
*/
int insert_to_link_list_tail(list list_, int date)
{
	list p = NULL;
        
        if (NULL == list_) {
            printf("list is NULL ...\n");
            exit(1);
        }
	p = (list)malloc(sizeof(list));
	if(NULL == p) {
		printf("malloc fialed !\n");
		exit(1);
	}
	while(list_->next) {
                   
            list_ = list_->next;    
        } 
        p->date = date;
        list_->next = p;
        p->next = NULL; 
	
	return 1;
	
}

void show_single_link_list (list head)
{
	if (NULL == head) {
		printf(" list is null ...\n");
		return;
	}
	head = head->next;
	while(head) {
		printf("date ---- > %d \n", head->date);
		head = head->next;
	}
	
	return;
}
/*
 * delete element from tail of link list
 * */
void delete_from_link_tail(list list_)
{
    if(NULL == list_) {
        printf("list is NULL ...\n");
        exit(1);
    }
    if(list_->next == NULL) {
        free(list_);
        list_ = NULL;
    }
    while(list_->next->next) {
        list_ = list_->next;
    }
    free(list_->next);
    list_->next= NULL;
    
    return ;
}
/*
 * delete from link head
 * */
void delete_from_link_head(list list_)
{   
    list p = NULL;
    if(NULL == list_) {
        printf("link is NULL ...\n");
        exit(1);
    }
    
    if(list_->next) {
        p = list_->next;
        list_->next = p->next;
        free(p);
    }
    return;
}
/*
 * get link list size
 * 
 * */
int get_link_size(list list_)
{
    int size = 0;
    if(NULL == list_) {
        printf("link is NULL ...\n");
        exit(1);
    }
    while(list_->next) {
        ++size;
        list_ = list_->next;
    }
    return size;
}
void delete_specific_date(list list_, int date)
{
    list p = NULL;
    int size = 0;
    if(NULL == list_) {
        printf("list is NULL ...\n");
        exit(1);
    }
    size = get_link_size(list_);
    if (size <= 0) {
        printf("link hasn't element ...\n");
        exit(1);
    }
    p = list_->next;
    while(p->date != date) {
        p = list_->next;
    }
  
   list_->next = p;
   free(list_);
    
    return;
}
int main()
{
	list head = NULL;
	int i;
	
	head = init_single_link_list();
#if 0
	for (i = 0; i < 2; i++) {
		
           //insert_to_link_list_head(head, i);
           insert_to_link_list_tail(head, i);
	}
#endif
	show_single_link_list(head);
        printf("list size is %d\n", get_link_size(head));
        //delete_from_link_tail(head);
        //delete_from_link_head(head);
        delete_specific_date(head, 0);
        show_single_link_list(head);	
}

双向链表

双向链表支持两个方向，每个节点有一个后继指针next指向后面的节点，还有一个前驱指针指向前面的节点。
在这里插入图片描述
双向链表简单实现：
double_linklist.h

#ifndef DOUBLE_LINKLIST_
#define DOUBLE_LINKLIST_

#include "stdbool.h"
typedef int ElementType;
typedef struct _double_link {
    ElementType date;
    struct _double_link *next;
    struct _double_link *pre;     
}double_linklist;

double_linklist *init_double_linklist();
bool insert_linklist_head(double_linklist* d_linklist, ElementType date);
ElementType delete(double_linklist* d_linklist);
void display(double_linklist* d_linklist);
bool isEmpty(double_linklist* d_linklist);

#endif

double_linklist.c

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

/*
@func :创建头结点和尾结点，新增的节点插入头结点和尾结点之间
*/
double_linklist *init_double_linklist()
{
    double_linklist *head = (double_linklist *)malloc(sizeof(double_linklist));
    if (!head) {
        perror("malloc failed.");
        exit(1);
    }
    head->next = NULL;
    head->pre = NULL;
    double_linklist *pNew = (double_linklist *)malloc(sizeof(double_linklist));
    if (!pNew) {
        perror("malloc failed.");
        exit(1);
    }
    pNew->next = NULL;
    pNew->pre = head;
    head->next = pNew;
    
    return head;
}
/*
@func: 头插法，新增的节点插入头结点后面
*/
bool insert_linklist_head(double_linklist* head, ElementType date)
{
    if (!head) {
        perror("d_linklist is NULL");
        exit(1);
    }
    double_linklist* pNew = (double_linklist *)malloc(sizeof(double_linklist));
    if (!pNew) {
        perror("malloc failed.");
        exit(1);
    }
    pNew->date = date;
    /*先确定新增节点的前后指针指向*/
    pNew->pre = head;
    pNew->next = head->next;
    head->next->pre = pNew;
    head->next = pNew;
    
    printf("insert %d\n", head->next->date);
    return true;
}
bool isEmpty(double_linklist* head)
{
    if (!head) {
        perror("d_linklist is NULL.");
        exit(1);
    }
    if (head->next->next == NULL && head->next->pre == head)
        return true;
    else
        return false;
}
/*
@func: 删除一个节点
*/
ElementType delete(double_linklist* head)
{
    if (!head) {
        perror("d_linklist is NULL.");
        exit(1);
    }
    if (isEmpty(head)) {
        printf("double linklist is empty.\n");
        exit(1);
    }
    double_linklist* pDel = head->next;
    ElementType val = pDel->date;
    
    pDel->next->pre = head;
    head->next = pDel->next;
    if (pDel) {
        free(pDel);
        pDel = NULL;
    }
    return val;
}

void display(double_linklist* head)
{
    if (!head) {
        perror("d_linklist is NULL.\n");
        exit(1);
    }
    if (isEmpty(head)) {
        printf("double linklist is empty.\n");
        exit(1);
    }
    double_linklist* tmp = head->next;
    while (tmp->next != NULL) {
        printf("val ---> %d\n", tmp->date);
        tmp = tmp->next;
    }
}
int main()
{
    double_linklist* d_link = init_double_linklist();
    insert_linklist_head(d_link, 20);
    insert_linklist_head(d_link, 10);
    printf("delete val is %d .\n", delete(d_link));
    printf("delete val is %d .\n", delete(d_link));
    display(d_link);
    
}

循环链表

单向循环链表

和单链表相比，循环链表的优点是从链尾到链头特别容易，适合处理具有环形结构特点的数据，如著名的约瑟夫问题。循环链表的简单实现如下：
robin_linklist.h

#ifndef ROBIN_LINKLIST_
#define ROBIN_LINKLIST_

#include "stdbool.h"
typedef int ElementType;
typedef struct _node {
    ElementType date;
    struct _node* next;
}robin_linklist;

robin_linklist* init_robin_linklist();
bool insert_to_robin_linklist(robin_linklist* link, ElementType date);
bool delete_from_robin_linklist(robin_linklist* link);
void display_robin_linklist(robin_linklist* link);
#endif

robin_linklist.c

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

robin_linklist* init_robin_linklist()
{
    robin_linklist *head = (robin_linklist *)malloc(sizeof(robin_linklist));
    if (!head) {
        perror("malloc failed.");
        exit(1);
    }
    /*next指针指向自己*/
    head->next = head;
    robin_linklist *node = (robin_linklist *)malloc(sizeof(robin_linklist));
    if (!node) {
        perror("malloc failed.");
        exit(1);
    }
    node->next = head;
    head->next = node;
    return head;
}
/*
@func : insert a element to linklist
*/
bool insert_to_robin_linklist(robin_linklist* link, ElementType date)
{
    if (!link) {
        perror("link is NULL.");
        exit(1);
    }
    robin_linklist* node = (robin_linklist *)malloc(sizeof(robin_linklist));
    if (!node) {
        perror("malloc failed.");
        exit(1);
    }
    node->date = date;
    node->next = link->next;
    link->next = node;
    
    return true;  
}
/*
@func : delete a element from linklist
*/
bool delete_from_robin_linklist(robin_linklist* link)
{
    if (!link) {
        perror("link is NULL.");
        exit(1);
    }
    if (link->next->next != link) {
        robin_linklist *tmp = link->next;
        link->next = tmp->next;
        return true;
    }else {
        printf("link is empty.\n");
        return false;
    }
}
void display_robin_linklist(robin_linklist* link)
{
    if (!link) {
        perror("link is NULL.");
        exit(1);
    }
    robin_linklist *tmp = link->next;
    while(link != tmp->next) {
      printf("val ---> %d\n", tmp->date);
      tmp = tmp->next;
    }
}
int main()
{
    /*test code*/
    robin_linklist *ro_linklist = init_robin_linklist();
    insert_to_robin_linklist(ro_linklist, 10);
    display_robin_linklist(ro_linklist);
    delete_from_robin_linklist(ro_linklist);
    display_robin_linklist(ro_linklist);
    delete_from_robin_linklist(ro_linklist);
      
}

双向循环链表

在这里插入图片描述
双向链表的简单实现：
double_robin_linklist.h

#ifndef DOUBLE_ROBIN_LINKLIST_
#define DOUBLE_ROBIN_LINKLIST_

#include "stdbool.h"

typedef int ElementType;
typedef struct _double_robin_link {
    ElementType date;
    struct _double_robin_link *next;
    struct _double_robin_link *pre;
}dou_robin_link;

dou_robin_link* init_double_robin_linklist();
bool insert_head(dou_robin_link * link, ElementType date);
ElementType delete(dou_robin_link* link);
bool isEmpty(dou_robin_link* link);
void display(dou_robin_link* link);

#endif

double_robin_linklist.c

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


dou_robin_link * init_double_robin_linklist()
{
    dou_robin_link* head = (dou_robin_link *)malloc(sizeof(dou_robin_link));
    if (!head) {
        perror("malloc failed.");
        exit(1);
    }
    head->next = head;
    head->pre = head;
    
    /*创建尾节点*/
    dou_robin_link *tail = (dou_robin_link *)malloc(sizeof(dou_robin_link));
    if (!tail) {
        perror("malloc failed.");
        exit(1);
    }
    tail->pre = head;
    tail->next = head;
    head->next = tail;
    
    return head;
}
bool isEmpty(dou_robin_link* link)
{
    if (!link) {
        perror("link is NULL.");
        exit(1);
    }
    if (link->next->next == link && link->next->pre == link) {
        
        printf("double robin linklist is empty.\n");
        return true;
    }
    else {
        return false;
    }
}
/*
@func： 头插法
*/
bool insert_head(dou_robin_link * link, ElementType date)
{
    if (!link) {
        perror("link is NULL.");
        exit(1);
    }
    dou_robin_link *pNew = (dou_robin_link *)malloc(sizeof(dou_robin_link));
    if (!pNew) {
        perror("malloc is NULL.");
        exit(1);
    }
    pNew->date = date;
    pNew->next = link->next;
    pNew->pre = link;
    
    link->next = pNew;
    link->next->next->pre = pNew;
    printf("insert -->%d\n", link->next->date);
    
    return true;
}
/*
@func: 头删法
*/
ElementType delete(dou_robin_link* link)
{
    if (!link) {
        perror("link is NULL.");
        exit(1);
    }
    if (isEmpty(link)) {
        exit(1);
    }
    dou_robin_link *pDel = link->next;
    ElementType val = pDel->date;
    link->next = pDel->next;
    pDel->next->pre = link;
    
    printf("delete ---> %d\n", val);
    if(pDel) {
        free(pDel);
        pDel = NULL;
    }
    return val;
}

void display(dou_robin_link* link)
{
    if(!link) {
        perror("link is NULL.");
        exit(1);
    }
    if(isEmpty(link)) {
        exit(1);
    }
    dou_robin_link* tmp = link->next;
    while (tmp->next != link && tmp->next->pre != link) {
        printf("val ---> %d\n", tmp->date);
        tmp = tmp->next;
    }
}
int main()
{
    dou_robin_link *head = init_double_robin_linklist();
    insert_head(head, 10);
    insert_head(head, 20);
    delete(head);
    display(head);
}
hytMay
关注
  • 17
    点赞
  • 踩
  • 63
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
《数据结构基础知识②》--单循环链表+双向链表+时间效率+比较
yyldeh的博客
03-27 2182
目录 一、单循环链表 1.概念 2.循环条件 3.尾指针表示循环链表 4.带尾指针的链表合并 二、双向链表 1.概念 2.双向循环链表 3.双向链表结构的对称性 4.双向链表的插入 5.双向链表的删除 三、单链表、循环链表、双向链表的时间效率比较 四、顺序表和链表的比较 1.链式存储结构的优缺点 2.存储密度 3.顺序表和链表比较 一、单循环链表 1.概念 2.循环条件 3.尾指针表示循环链表 4.带尾指针的链表合并 ...
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 3106
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
单链表，双链表，循环链表的区别
code changes world!
12-28 9502
单向链表（单链表） 单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向表中的下一个节点，而最后一个节点则 指向一个空值NULL。 单向链表只可向一个方向遍历。查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。也可以提前把一个节点的位置另外保存起来，然后直接访问。 双向链表,（双链表） 双向链表中不
数据结构-双链表(图解)
最新发布
2302_78381559的博客
04-20 1615
双链表是一种常用且重要的线性数据结构，它在计算机科学和软件工程中扮演着不可或缺的角色。相较于单链表，双链表的每个节点包含两个指针，分别指向其前驱节点（previous node）和后继节点（next node），这一特性使得双链表在数据操作上具有更高的灵活性。
如何判断一个单链表是循环链表
江海细流的专栏
08-17 7546
1.循环链表的特点是收尾相接，没有头指针，也没有尾指针。如果去遍历循环链表，则是s
C语言之链表：单向链表，循环链表，双向链表
哒宰的博客
11-22 2186
C语言之链表：单向链表，循环链表，双向链表 提起链式存储结构，其与数组是两个非常基础的数据结构，每当提到链式存储结构时，一般情况下我们都会将其与数组放到一块儿来比较。 对于数组与链表，从结构上来看，数组是需要一块连续的内存空间来存储数据，对内存 的要求非常高，比如说我们申请一个100M大小的数组，而如果我们的内存可用空间大于100M，但是没有连续的100M可用空间，那即便是我们的内存空间充足，在申请空间时也会申请失败 而对于链表来说，他对内存空间的要求就不会有那么高，它并不需要一块连续的内存空间，只要内存空
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
20多张无水印图熟练理解和掌握单链表-双向链表-循环链表（原理+C源码）
05-29
循环链表结点设计（以单循环链表为例） 16 循环单链表初始化 17 循环链表的创建操作 18 循环单链表的插入操作 19 循环单链表的删除操作 20 循环单链表的遍历 22 进阶概念——双向循环链表 23 关于链表的总结 23
循环链表和双向链表.ppt
09-20
循环链表的插入和删除操作与单链表类似，但需要注意的是，由于没有明确的尾部标志，因此在遍历时需使用条件如`curr.next() != head`来避免无限循环。 双向链表则更进一步，每个链表节点不仅包含一个指向后继节点的...
c语言数组指定位置插入和删除-玩转C语言链表，单链表双向链表的建立遍历插入删除... 数组和链表.pdf
04-18
C语言数组指定位置插入和删除-玩转C语言链表，单链表双向链表的建立遍历插入删除... 本文主要讲解了C语言中数组和链表的概念及操作，包括数组指定位置插入和删除、链表的结构、静态链表和动态链表、单链表的建立和...
带头结点的双向循环链表
07-17
首先，双向循环链表与单链表的主要区别在于每个节点不仅包含数据，还包含两个指针：一个指向前一个节点，另一个指向后一个节点。在双向循环链表中，最后一个节点的“后继”指针会指向头结点，而头结点的“前驱”指针...
循环链表（单循环、双循环）(数据结构与算法)
AII_IIA的博客
11-04 2192
循环单链表与普通单链表的主要区别在于，循环单链表的尾节点的指针不是指向 nullptr，而是指向头节点，形成一个闭环。这意味着，在循环单链表中，可以通过尾节点的指针重新回到头节点。循环双链表与普通双链表的主要区别在于，循环双链表既具有双向链表的前驱和后继关系，也具有循环遍历的能力。
简单理解单链表、双链表、循环单链表、循环双链表
ytswld的博客
11-03 650
简单理解单链表、双链表、循环单链表、循环双链表 单链表只有后继指针 双链表有后继指针和前驱指针 循环单链表尾指针指向了头指针 循环双链表头结点的前驱指针指向了尾结点，尾结点的后继指针指向了头结点 ...
链表的基本操作（单链表、双链表、循环链表、静态链表）
shengruyu的博客
07-04 531
链表的基本操作（单链表、双链表、循环链表）
链表基础知识
小菜鸡
03-08 676
链表 基础知识 关于链表，你该了解这些！ 什么是链表，链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。 链接的入口节点称为链表的头结点也就是head。 如图所示： 链表的类型 接下来说一下链表的几种类型: 单链表 刚刚说的就是单链表。 双链表 单链表中的节点只能指向节点的下一个节点。 双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。 双链表 既可以向前查询也可以向
单向链表和双向链表有什么区别？各自有什么优缺点？
热门推荐
m0_37914467的博客
07-28 1万+
1、指向不bai同：单向链表只有du一个指向下一结点的指针，zhi双向链表除了有一个指dao向下一结点的指针外，还有一个指向前一结点的指针。 2、功能不同：单向链表只能next ，双向链表可以return。 3、单双向不同：单链表只能单向读取，双向链表可以通过prev()快速找到前一结点。 单向链表优缺点： 1、优点：单向链表增加删除节点简单。遍历时候不会死循环； 2、缺点：只能从头到尾遍历。只能找到后继，无法找到前驱，也就是只能前进。 双向链表优缺点： 1、优点：可以找到前驱和后继，可进可退
Go语言学习笔记【10】 数据结构之单链表、双链表、循环链表
LC520730的博客
08-10 489
go实现单链表的头/尾部插入、删除，头尾元素的获取，判断元素是否包含，链表反转，循环链表及Josephus问题
链表——循环单链表，循环双链表及静态链表
薛定谔的猫的博客
04-18 3405
文章目录循环链表循环单链表循环双链表静态链表说明 循环链表  循环链表一般包括循环单链表和循环双链表，如下图所示： 循环单链表   循环单链表与单链表的区别在于，表中最后一个结点的指针不是NULL，而改为指向头结点，从而使整个链表形成一个环。   一般对循环单链表只设尾指针不设头指针，其原因是，如果设的是头指针，对表尾进行操作需要O(n)的时间复杂度，而若设的是尾指针r，那么r->next即为头指针，对表头与表尾进行操作都只需要O(1)的时间复杂度。  单链表与循环单链表：  详细的单链表操作请参
04 2 线性表3-其它链表1
08-03
本文档主要讲解了线性表的不同链式表示和实现，包括单链表、循环链表和双向链表。其中，线性表是一种基本的数据结构，由相同类型的元素构成，按照线性顺序排列。链表作为线性表的链式存储方式，允许逻辑上相邻的元素...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值