双链表和循环双链表复习

最新推荐文章于 2024-10-03 23:25:31 发布
最新推荐文章于 2024-10-03 23:25:31 发布
阅读量4.1k 收藏 9
点赞数
分类专栏： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hujiaqi2018/article/details/81482320
版权

首先不管是单链表还是双链表或者循环双链表，都是为了提高访问效率，比如同样的插入操作，顺序表需要用数组移动元素，访问效率比较差，相反链表只需要移动指针，而且顺序表是有最大空间的，而链表没有。

双链表格式：


struct node     //双向链表
{
    ElemType data;   //数据域
    struct node *next;   //指针域   指向下一个后继方向
    struct node *prior;           //指向前一个前驱方向
};

结点指向 p == p->prior->next == p->next->prior

双向链表和单链表各个功能使用的区别：

1.初始化；

int LinkInit(Node **l)
{
    *l = (Node *)malloc(sizeof(Node) * 1);   //分配头结点   l 就是头指针
    if (NULL == *l)
    {
        return FAILURE;
    }

    (*l)->next = NULL;    //头结点指针域为空
    (*l)->prior = NULL;   //双向链表，头结点prior指针为空。可以看出相比单链表多分配一个指针

    return SUCCESS;
}

 

 

2.插入函数：

int LinkInsert(Node *l, int n, ElemType e)  //n 插入的位置
{
    Node *p = l;
    int k = 1;   //k 移动的次数

    if (NULL == l)
    {
        return FAILURE;
    }

    while (k < n && p != NULL)
    {
        p = p->next;
        k++;
    }

    if (k > n || p == NULL)
    {
        return FAILURE;
    }

    Node *q = (Node *)malloc(sizeof(Node) * 1);
    if (NULL == q)
    {
        return FAILURE;
    }

    q->data = e;
    q->prior = p;//多了一步指向p头指针的前继
    q->next = p->next;
    p->next = q;
    if (NULL != q->next)    //多了一步如果q不是最后一个结点（画图理解会发现，后面p后面结点如果没有这一步会少一个前驱）
    {
        q->next->prior = q;
    }

    return SUCCESS;
}

3.浏览函数和单链表一样

int LinkTraverse(Node *l, void (*p)(ElemType))//比较函数判断是否相等
{
    if (NULL == l)
    {
        return FAILURE;
    }
    Node *q = l;

    while (q->next)
    {
        q = q->next;
        p(q->data);
    }

    return SUCCESS;
}

4，长度函数一样

int LinkLength(Node *l)
{
    if (NULL == l)
    {
        return FAILURE;
    }

    int len = 0;
    Node *p = l->next;

    while (p)
    {
        len++;
        p = p->next;
    }

    return len;
}

 

5.判空函数一样

int LinkEmpty(Node *l)
{
    return (l->next == NULL) ? TRUE : FALSE;
}

6删除函数：

int LinkDelete(Node *l, int p, ElemType *e)//删除位置p
{
    int k = 1;
    Node *q = l;

    if (l == NULL)
    {
        return FAILURE;
    }

    while (k < p && q != NULL)//移动被删元素前一个
    {
        q = q->next;
        k++;
    }

    if (k > p || q == NULL)
    {
        return FAILURE;
    }

    Node *n = q->next;//让n指向q后面要删的元素
    *e = n->data;//将被删元素放入e中
    q->next = n->next;  //指向被删元素的后面一个 ，如果n是最后一个指向nuLL
    if (n->next != NULL)     //如果不是最后一个进入循环  
    {
        n->next->prior = q;//让n后面的元素的前继指向q
    }
    free(n);释放删除元素

    return SUCCESS;
}

 

清空函数的区别：

int LinkClear(Node *l)
{
    if (NULL == l)
    {
        return FAILURE;
    }

    Node *p = l->next;

    while (p)
    {
        l->next = p->next;
        //p->next->prior = l;//可有可无，目的是让后面结点的前驱指向头结点
        free(p);
        p = l->next;//防止p为野指针，free(P)会让变成NULL，并将p往后指向，依次释放,直到最后一个结点
    }

    return SUCCESS;
}

 

注意：双链表没有倒叙的说法
二：双链循环链表

循环链表，和单链表最大的区别，单链表最后指向NULL；而循环链表指向头结点或者第一个结点

 

如图：可以看出首尾的链表，在空表的时候都是头尾都是指向自己的。

所以初始化也与单链表有一定区别：

int LinkInit(Node **l)
{
    *l = (Node *)malloc(sizeof(Node) * 1);   //分配头结点   l 就是头指针
    if (NULL == *l)
    {
        return FAILURE;
    }

    (*l)->next = (*l);    //后继指向自己
    (*l)->prior = (*l);   //前驱指向自己

    return SUCCESS;
}

插入函数：

int LinkInsert(Node *l, int n, ElemType e)  //n 插入的位置
{
    Node *p = l;
    int k = 1;   //k 移动的次数

    if (NULL == l)    //入参判断
    {
        return FAILURE;
    }

    if (n > LinkLength(l) + 1)    //超过最大长度报错，由于是循环链表，最后会回到头结点
    {
        return FAILURE;
    }

    while (k < n)     //***
    {
        p = p->next;
        k++;
    }


    if (k > n)    //循环次数大于插入位置，会让数据变得不准确，比如n=0,k=1,不进入while循环，数据被送入头结点
    {
        return FAILURE;
    }

    Node *q = (Node *)malloc(sizeof(Node) * 1);
    if (NULL == q)
    {
        return FAILURE;
    }


    q->data = e;
    q->prior = p;
    q->next = p->next;
    p->next = q;
    if (l != q->next)    //如果q不是最后一个结点 **
    {
        q->next->prior = q;
    }

    return SUCCESS;
}
 

浏览函数：

 

int LinkTraverse(Node *l, void (*p)(ElemType))
{
    if (NULL == l)
    {
        return FAILURE;
    }
    Node *q = l;

    while (q->next != l)     //不等于本身  
    {
        q = q->next;
        p(q->data);
    }

    return SUCCESS;
}

测试长度函数：

int LinkLength(Node *l)
{
    if (NULL == l)
    {
        return FAILURE;
    }

    int len = 0;
    Node *p = l->next;

    while (p != l)   //不等于本身 **
    {
        len++;
        p = p->next;
    }

    return len;
}

判断是否为空函数

int LinkEmpty(Node *l)
{
    return (l->next == l && l->prior == l) ? TRUE : FALSE;  //前驱和后继指向头结点，判断为空表
}

元素获取函数

int GetElem(Node *l, int p, ElemType *e)    //p 位置
{
    if (NULL == l || p < 1)   //入参判断  p不能小于0
    {
        return FAILURE;
    }

    Node *q = l->next;   //双向循环链表，q指向第一个结点  //**
    int i;

    for (i = 1; i < p && q != l; i++)    //循环p次，同时满足q不为空  双向循环链表 i = 1**
    {
        q = q->next;
    }

    if (q == l)      //如果q为空，说明p（位置）大于长度  **这里要用q=L来判断插入位置是否大于长度
    {
        return FAILURE;
    }

    *e = q->data;     //q已经指向第p个结点

    return SUCCESS;
}

查询函数：

 

int LocateElem(Node *l, ElemType e, int (*p)(ElemType, ElemType))
{
    if (NULL == l)
    {
        return FAILURE;
    }
    
    Node *q = l->next;
    int len = 1;

    while (q != l)     //双向循环链表  最后指向头结点
    {
        if (p(e, q->data) == TRUE)
        {
            return len;
        }
        q = q->next;
        len++;
    }

    return FAILURE;
}

 

 

删除函数：

int LinkDelete(Node *l, int p, ElemType *e)
{
    int k = 1;
    Node *q = l;

    if (l == NULL)
    {
        return FAILURE;
    }

    if (p > LinkLength(l) + 1)   //判断位置p是否合法  ，因为相对于普通链表没有p=nuLL末尾判断条件
    {
        return FAILURE;
    }

    while (k < p)  //**
    {
        q = q->next;
        k++;
    }

    if (k > p)  //**
    {
        return FAILURE;
    }

    Node *n = q->next;
    *e = n->data;
    q->next = n->next;   
                         //如果不是最后一个  **

    n->next->prior = q;
    free(n);

    return SUCCESS;
}

 

清空函数：

int LinkClear(Node *l)
{
    if (NULL == l)
    {
        return FAILURE;
    }

    Node *p = l->next;

    while (p != l)  //不回到头结点时
    {
        l->next = p->next;
        //p->next->prior = l;
        free(p);
        p = l->next;
    }

    l->prior = l;   //**

    return SUCCESS;
}

 

 

hujiaqi2018
关注
专栏目录
数据结构知识点总结04-(第二章.线性表)-双向链表定义、循环单链表、、循环双向链表、静态链表、顺序表与链表的比较
随风浪仔的专栏
02-26 507
数据结构知识点总结-线性表（3）-双向链表定义、循环单链表、、循环双向链表、静态链表、顺序表与链表的比较
【数据结构】第二章线性表：双链表、静态链表、循环链表、静态链表、顺序表与链表比较
weixin_37706349的博客
10-26 1354
2.3.3 双链表 第二章单链表中学到： 单链表：无法逆向检索，有时候不太方便； 双链表：双向链表，可进可退，存储密度更低； 存储密度 = （结点数据本身所占的存储量）/（结点结构所占的存储总量） 计算结构体大小时需要考虑其内存布局，结构体在内存中存放是按单元存放的，每个单元多大取决于结构体中最大基本类型的大小。 一、双链表的定义 // 双向链表定义 typedef struct DNode{ // 定义双链表结点类型 ElemType data; // 数据域 struc
第二章——双链表和循环双链表
weixin_55835175的博客
09-22 550
线性表——双链表和循环双链表 双链表的定义在链表那里就介绍过了，这里就不重复介绍了。 双链表和循环双链表 同样地，我们用结构体来声明链表中的一个结点： struct DLinkNode{ElemType data; DLinkNode *prior; DLinkNode *next;}; //定义双链表结点类型,prior指向前一个结点,next指向后一个结点 和单链表基本是一样的。 双链表和循环双链表基本运算的实现 这里会提供双链表和循环双链表基本运算的实现及代码。 建立双链表——头插法 和单链表
双链表与循环链表
thdwx的博客
09-19 655
双链表与循环链表 最好在表头和表尾都加上哑节点，这样不论是增加还是删除，都不会改变表头和表尾的地址。因为在增删表头或表尾元素时，必须要记住表尾或是表头的地址，如果不适用哑节点的话，就需要两个专门的变量来存放表头和表尾的地址。在实现单链表时，如果在表头加上哑节点，实现起来就会比较容易，因为这样表头的地址就是始终不变的。双链表是指在单链表的基础上，每一个结构体中多出来一个指针用来指向上一个结构体。在单链表的基础上，使得表尾部的元素的next指针指向表头。
数据结构——双向链表
最新发布
zoelinkailuo的博客
10-03 837
/指针保存下一个结点的地址//指针保存前一个结点的地址}LTNode;
链表之循环双链表
蓝亚之舟的博客
05-09 808
双节点类：public class DoubleNode&lt;T&gt; { public T data; public DoubleNode&lt;T&gt; prev, next; public DoubleNode(T data, DoubleNode&lt;T&gt; prev, DoubleNode&lt;T&gt; next) { this.data = data; ...
双向链表和双向循环链表_如何以简单的方式处理双向链表
weixin_26755331的博客
09-16 271
双向链表和双向循环链表 介绍： (Introduction:) Before going into doubly linked list implementation, you must have basic knowledge about Linked List. If you haven’t read about Linked List or Singly Linked List yet, c...
数据结构-双链表和双循环链表(C语言代码)
weixin_50246370的博客
08-10 403
双链表和双循环链表单链表双循环链表 单链表 单向链表特点：   1.可以轻松的到达下一个节点, 但是回到前一个节点是很难的.   2.只能从头遍历到尾或者从尾遍历到头(一般从头到尾) 双向链表特点   1.每次在插入或删除某个节点时, 需要处理四个节点的引用, 而不是两个. 实现起来要困难一些   2.相对于单向链表, 必然占用内存空间更大一些.   3.既可以从头遍历到尾, 又可以从尾遍历到头 双向链表的定义:   双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接
Python实现单链表、单循环链表、双链表及双循环链表
MrLittleDog的博客
07-01 2463
文章目录前言单链表单循环链表双链表双循环链表错误纠正说明时间复杂度比较关于头结点 前言 博主最近在复习算法与数据结构，由于平时主力语言是Python，所以找了个用Python讲解数据结构的视频看了下，链接为：https://www.bilibili.com/video/av20982396?p=1。 关于链表，视频里讲的很清楚，但是代码有几处小错误，现将其代码纠正，并添加视频里没有讲到的双循环链表...
链表数据结构复习：单链表、循环链表与双向链表
"数据结构第3章复习重点涵盖了单链表、循环链表和双向链表的基本概念、特点以及相关的算法设计。主要内容包括单链表的定义、抽象数据类型、构造函数、搜索、插入和删除操作；循环链表的定义、特点及操作；双向链表的...
链表数据结构详解：单链表、循环链表与双向链表
本次复习主要聚焦于三种基本类型的链表：单链表、循环链表和双向链表。 1. 单链表： 单链表是由一系列节点构成的线性结构，每个节点包含数据元素和指向下一个节点的指针。由于节点在内存中的存储位置可以不连续，...
循环双链表
09-12
基于C高级的双向循环链表，可以选择头插还是尾插两种插入方式，及增加节点，删除节点
数据结构（三）——双链表、循环链表
scfor333的博客
11-23 292
线性表——双链表、循环链表 双链表概念 ​ 双链表是链表的一种，也叫双向链表，因为双链表的每个物理节点增加一个指向后继节点的指针域和一个指向前驱节点的指针域 循环链表概念 ​ 循环链表也是链表的一种，他与单链表唯一的区别就是，循环链表的最后一个节点将指向头节点 双链表定义 ​ 根据概念不难理解，双链表即在单链表的基础上，增加一个指向前驱节点的指针域，这里用 prior 表示 typedef...
【数据结构】四、双向链表和双向循环链表
lieam的博客
07-11 2457
【数据结构】四、双向链表和双向循环链表
双向链表和双向循环链表的区别？
学亮编程手记
01-17 727
双向循环链表： 最后一个节点的 next 指向 head，而 head 的 prev 指向最后一个节点，构成一个环。双向链表： 包含两个指针，一个 prev 指向前一个节点，一个 next 指向后一个节点。
【数据结构】-循环链表(双链表）
RunningSnail的博客
07-21 968
循环双链表-带头结点1.头文件及类型定义2.循环双链表结点类型定义3.函数声明4.基本操作4.1 初始化循环双链表4.2 判空4.3 判断表尾结点4.4 按位查找4.5 指定结点后插4.6 删除指定结点后继结点4.7 创建循环双链表4.8 遍历4.9 销毁循环双链表4.10 main函数5.小结 1.头文件及类型定义 #include<stdio.h> #include<stdlib.h> #define ElemType int using namespace std; 2.循环
双向链表和循环链表的区别
weixin_51420051的博客
11-14 5516
双向链表： 1、为了方便编程，以及节点的插入删除，可以在首尾增加一个空节点，方便一系列的操作和判断，最后一个节点指针指向空数据的节点或者指向空。 2、双向链表在访问元素时，可以从任何结点开始任意向前向后双向访问节点元素，不像循环单链表只能按顺序访问后节点。 3、因为有前后两个指针，双向链表删除前驱和后驱节点，以及插入节点的操作非常便捷。 循环链表： 1、循环链表没有尾指针，必须将最后的一个节点的后指针指向头节点 2、循环链表在访问元素时，可以从任何一个结点开始，但是只能顺序向后访问节点元素 3、循环链表在
双向链表和循环链表
yanyanwenmeng的博客
09-13 511
一、双向链表 每个结点有两个指针域和若干数据域，其中一个指针域指向它的前趋结点，一个指向它的后继结点。它的优点是访问、插入、删除更方便，速度也快了。但“是以空间换时间”。 【数据结构的定义】 struct node{ int data; node *pre,*next;//pre指向前趋，next指向后继 }; node *head,*p,*q,*r; void inser
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值