【数据结构算法】③、双向链表和双向循环链表的实现、双向链表的创建-遍历-插入-删除-删除指定元素-查询指定元素、双向循环链表的创建-遍历-插入删除

已于 2022-03-22 21:35:43 修改
阅读量1.8k 收藏 17
点赞数 2
分类专栏： # 数据结构与算法 文章标签： 数据结构 算法 数据结构与算法 双向链表 双向循环链表
于 2022-03-22 21:35:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42816425/article/details/123666957
版权

【数据结构算法】③、双向链表和双向循环链表的实现

数据结构与算法 总共分为19个系列
①、数据结构与算法[基础]+线性结构部分内容篇
②、单向循环链表的创建插入删除实现篇
③、双向链表和双向循环链表的实现篇

请添加图片描述

③、双向链表和双向循环链表的实现篇

⭐️本文章知识点大纲

双向链表

  1. 双向链表的介绍
  2. 双向链表的介绍-创建遍历
  3. 双向链表的插入
  4. 双向链表的删除
  5. 双向链表的删除指定元素
  6. 双向链表的查找指定元素

双向循环链表

  1. 双向循环链表的介绍
  2. 双向循环链表的介绍-创建遍历
  3. 双向循环链表的插入
  4. 双向循环链表的删除

⭐️双向链表

①、线性表 - 双向链表的介绍

双向链表(创建/插入/删除/查找/替换)

双向链表的特点
每个节点都包含3个部分

  1. 包含前驱 prior
  2. 包含数据源
  3. 包含后继 指针域

1.1 流程图 - 双向链表 - 单个节点 结构

请添加图片描述

1.2 流程图 - 双向链表 整个链表

双向链表 带有头节点 和不带有头节点的结构图
链表最好不要使用头插法。因为头插法插入的数据是倒序的

请添加图片描述

②、线性表 - 双向链表 创建

2.1 流程图 - 双向链表 创建

请添加图片描述

双向链表的 头节点的前驱不是L,而是空,后继也是空。因为我们不知道后继有没有东西。所以后继也要是空的。

2. 🌰案例 - 双向链表 - 创建、遍历 代码实现

#include <stdio.h>
#include "string.h"
#include "ctype.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"

#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OK 1

#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */

//定义结点
typedef struct Node{
    ElemType data;
    struct Node *prior; // 前驱
    struct Node *next; // 后继
}Node;

typedef struct Node * LinkList;

//5.1 创建双向链接
Status createLinkList(LinkList *L){
    
    //*L 指向头结点
    *L = (LinkList)malloc(sizeof(Node));
    if (*L == NULL) return ERROR;
    
    (*L)->prior = NULL;
    (*L)->next = NULL;
    (*L)->data = -1;
    
    //新增数据
    LinkList p = *L; // 创建一个临时变量 指向*L
    // 使用尾插法插入数据 插入10个数据    
    for(int i=0; i < 10;i++){
        
        //1.创建1个临时的结点
        LinkList temp = (LinkList)malloc(sizeof(Node));
        temp->prior = NULL;
        temp->next = NULL;
        temp->data = i;
        
        //2.为新增的结点建立双向链表关系
        //① temp 是p的后继
        p->next = temp;
        //② temp 的前驱是p
        temp->prior = p;
        //③ p 要记录最后的结点的位置,方便下一次插入
        p = p->next;
        
    }
    
    return OK;
}

//5.2 打印循环链表的元素
void display(LinkList L){
    
    //  不需要把头结点打印出来 
    // 所以拿到L->next 也就是头结点的下一个结点
    LinkList temp = L->next;
    // 判断打印的结点是不是空
    if(temp == NULL){
        printf("打印的双向链表为空!\n");
        return;
    }
    // 循环打印
    while (temp) {
        printf("%d  ",temp->data);
        temp = temp->next;
    }
    printf("\n");
    
}


int main(int argc, const char * argv[]) {
    // insert code here...
    printf("Hello, World!\n");
    
    Status iStatus = 0;
    LinkList L;
    int temp,item,e;
    
    iStatus =  createLinkList(&L);
    printf("iStatus = %d\n",iStatus);
    printf("链表创建成功,打印链表:\n");
    display(L);

    return 0;
}

③、线性表 - 双向链表 插入

比如我要往AB中间插入一个C
也就是ACB
那么步骤流程就是
1.1 先找到A结点§
2.1 创建C结点 (temp)
3.1 把B(p-next)的前驱指向C .
3.2 把C结点(temp)的后继(next)指向B(p-next)。
4.1 把A的后继(next)指向C(temp).
4.2 把C结点的前驱指向A

如果插入到尾部的时候情况
比如从ABC
插入一个D
那么步骤就是
1.1 先找到C结点§
2.1 创建D结点(temp)(后继一开始就是空的)
3.1 先把D的前驱 指向 C
3.2 把C的后继(p->next)(之前是空的) 指向D

3.1 流程图 - 双向链表 插入

请添加图片描述

3.2 结果图 - 双向链表 插入

请添加图片描述

3. 🌰案例 - 双向链表 - 插入 代码实现

//5.3 双向链表插入元素
Status ListInsert(LinkList *L, int i, ElemType data){
    // 不能插入到头结点 头结点相当于牵头人
    //1. 插入的位置不合法 为0或者为负数
    if(i < 1) return ERROR;
    
    //2. 新建结点
    LinkList temp = (LinkList)malloc(sizeof(Node));
    temp->data = data;
    temp->prior = NULL;
    temp->next = NULL;
    
    //3.将p指向头结点!
    LinkList p = *L;
    
    //4. 找到插入位置i直接的结点
    // 这里是找插入的位置
    for(int j = 1; j < i && p;j++)
        p = p->next;
    
    //5. 如果插入的位置超过链表本身的长度
    if(p == NULL){
        return  ERROR;
    }
    
    //6. 判断插入位置是否为链表尾部;
    if (p->next == NULL) {
        
        p->next = temp;
        temp->prior = p;
    }else
    {
        //1️⃣ 将p->next 结点的前驱prior = temp
        p->next->prior = temp;
        //2️⃣ 将temp->next 指向原来的p->next
        temp->next = p->next;
        //3️⃣ p->next 更新成新创建的temp
        p->next = temp;
        //4️⃣ 新创建的temp前驱 = p
        temp->prior = p;
    }
    
    return  OK;
}

④、线性表 - 双向链表 删除

比如我要往ABC中间删除B
删除的步骤

  1. 先找到A(变量p)
  2. 创建一个临时变量(delTemp)记录B
  3. 用A(变量p)的后继(next)
    指向
    B的前驱(deltemp的prior)的
    指向
    C的前驱(C的prior)
  4. 然后C的前驱指向A的后续
  5. 把B结点删除 释放掉

4.2 结果图 - 双向链表 删除

请添加图片描述

4. 🌰案例 - 双向链表 - 删除 代码实现

//5.4 删除双向链表指定位置上的结点
// e表示删除的元素 可以返回回去
Status ListDelete(LinkList *L, int i, ElemType *e){
    
    int k = 1;
    LinkList p = (*L);
    
    //1.判断双向链表是否为空,如果为空则返回ERROR;
    if (*L == NULL) {
        return ERROR;
    }
    
  
    //2. 将指针p移动到删除元素位置前一个
    while (k < i && p != NULL) {
        p = p->next;
        k++;
    }
    
    //3.如果k>i 或者 p == NULL 则返回ERROR
    if (k>i || p == NULL) {
        return  ERROR;
    }
    
    //4.创建临时指针delTemp 指向要删除的结点,并将要删除的结点的data 赋值给*e,带回到main函数
    LinkList delTemp = p->next;
    *e = delTemp->data;
    
    //5. p->next 等于要删除的结点的下一个结点
    p->next = delTemp->next;
    
    //6. 如果删除结点的下一个结点不为空,则将将要删除的下一个结点的前驱指针赋值p;
    if (delTemp->next != NULL) {
        delTemp->next->prior = p;
    }
    
    //7.删除delTemp结点
    free(delTemp);
    
    return OK;
    
}

⑤、线性表 - 双向链表 删除指定元素

比如我从一个双向链表1-10
我要删除5(变量p)
步骤

  1. 找到p的前驱(prior) - 也就是4的(p->prior)
  2. 找到4的next 指向 6的前驱
    (p->next->prior)
  3. 没有找到 那么就将p=p->next

5. 🌰案例 - 双向链表 - 删除指定元素 代码实现

//5.5 删除双向链表指定的元素
Status LinkListDeletVAL(LinkList *L, int data){
    
    LinkList p = *L;
    
    //1.遍历双向循环链表
    while (p) {
       
        //2.判断当前结点的数据域和data是否相等,若相等则删除该结点
        if (p->data == data) {
            
            //修改被删除结点的前驱结点的后继指针,参考图上步骤1️⃣
            p->prior->next = p->next;
            //修改被删除结点的后继结点的前驱指针,参考图上步骤2️⃣
            if(p->next != NULL){
                p->next->prior = p->prior;
            }
            //释放被删除结点p
            free(p);
            //退出循环
            break;
        }
        
        //没有找到该结点,则继续移动指针p
        p = p->next;
    }
    
    return OK;
    
}

⑥、线性表 - 双向链表 查找元素

6. 🌰案例 - 双向链表 - 删除指定元素 代码实现

//5.6.1 在双向链表中查找元素
int selectElem(LinkList L,ElemType elem){
    
    LinkList p = L->next;
    int i = 1;
    while (p) {
        if (p->data == elem) {
            return i;
        }
        
        i++;
        p = p->next;
    }
    
    return  -1;
}

⑦、线性表 - 双向链表 更新

7. 🌰案例 - 双向链表 - 更新 代码实现

//5.6.2 在双向链表中更新结点
Status replaceLinkList(LinkList *L,int index,ElemType newElem){
    LinkList p = (*L)->next;
    
    for (int i = 1; i < index; i++) {
        p = p->next;
    }
    
    p->data = newElem;
    return OK;
}

💡⑧、双向链表end - 双向链表 - 综合代码

#include <stdio.h>
#include "string.h"
#include "ctype.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"

#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OK 1

#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */

//定义结点
typedef struct Node{
    ElemType data;
    struct Node *prior;
    struct Node *next;
}Node;

typedef struct Node * LinkList;

//5.1 创建双向链接
Status createLinkList(LinkList *L){
    
    //*L 指向头结点
    *L = (LinkList)malloc(sizeof(Node));
    if (*L == NULL) return ERROR;
    
    (*L)->prior = NULL;
    (*L)->next = NULL;
    (*L)->data = -1;
    
    //新增数据
    LinkList p = *L;
    for(int i=0; i < 10;i++){
        
        //1.创建1个临时的结点
        LinkList temp = (LinkList)malloc(sizeof(Node));
        temp->prior = NULL;
        temp->next = NULL;
        temp->data = i;
        
        //2.为新增的结点建立双向链表关系
        //① temp 是p的后继
        p->next = temp;
        //② temp 的前驱是p
        temp->prior = p;
        //③ p 要记录最后的结点的位置,方便下一次插入
        p = p->next;
        
    }
    
    return OK;
}

//5.2 打印循环链表的元素
void display(LinkList L){
    
    LinkList temp = L->next;
    
    if(temp == NULL){
        printf("打印的双向链表为空!\n");
        return;
    }
    
    while (temp) {
        printf("%d  ",temp->data);
        temp = temp->next;
    }
    printf("\n");
    
}

//5.3 双向链表插入元素
Status ListInsert(LinkList *L, int i, ElemType data){
    
    //1. 插入的位置不合法 为0或者为负数
    if(i < 1) return ERROR;
    
    //2. 新建结点
    LinkList temp = (LinkList)malloc(sizeof(Node));
    temp->data = data;
    temp->prior = NULL;
    temp->next = NULL;
    
    //3.将p指向头结点!
    LinkList p = *L;
    
    //4. 找到插入位置i直接的结点
    for(int j = 1; j < i && p;j++)
        p = p->next;
    
    //5. 如果插入的位置超过链表本身的长度
    if(p == NULL){
        return  ERROR;
    }
    
    //6. 判断插入位置是否为链表尾部;
    if (p->next == NULL) {
        
        p->next = temp;
        temp->prior = p;
    }else
    {
        //1️⃣ 将p->next 结点的前驱prior = temp
        p->next->prior = temp;
        //2️⃣ 将temp->next 指向原来的p->next
        temp->next = p->next;
        //3️⃣ p->next 更新成新创建的temp
        p->next = temp;
        //4️⃣ 新创建的temp前驱 = p
        temp->prior = p;
    }
    
    return  OK;
}

//5.4 删除双向链表指定位置上的结点
// e表示删除的元素 可以返回回去
Status ListDelete(LinkList *L, int i, ElemType *e){
    
    int k = 1;
    LinkList p = (*L);
    
    //1.判断双向链表是否为空,如果为空则返回ERROR;
    if (*L == NULL) {
        return ERROR;
    }
    
  
    //2. 将指针p移动到删除元素位置前一个
    while (k < i && p != NULL) {
        p = p->next;
        k++;
    }
    
    //3.如果k>i 或者 p == NULL 则返回ERROR
    if (k>i || p == NULL) {
        return  ERROR;
    }
    
    //4.创建临时指针delTemp 指向要删除的结点,并将要删除的结点的data 赋值给*e,带回到main函数
    LinkList delTemp = p->next;
    *e = delTemp->data;
    
    //5. p->next 等于要删除的结点的下一个结点
    p->next = delTemp->next;
    
    //6. 如果删除结点的下一个结点不为空,则将将要删除的下一个结点的前驱指针赋值p;
    if (delTemp->next != NULL) {
        delTemp->next->prior = p;
    }
    
    //7.删除delTemp结点
    free(delTemp);
    
    return OK;
    
}

//5.5 删除双向链表指定的元素
Status LinkListDeletVAL(LinkList *L, int data){
    
    LinkList p = *L;
    
    //1.遍历双向循环链表
    while (p) {
       
        //2.判断当前结点的数据域和data是否相等,若相等则删除该结点
        if (p->data == data) {
            
            //修改被删除结点的前驱结点的后继指针,参考图上步骤1️⃣
            p->prior->next = p->next;
            //修改被删除结点的后继结点的前驱指针,参考图上步骤2️⃣
            if(p->next != NULL){
                p->next->prior = p->prior;
            }
            //释放被删除结点p
            free(p);
            //退出循环
            break;
        }
        
        //没有找到该结点,则继续移动指针p
        p = p->next;
    }
    
    return OK;
    
}

//5.6.1 在双向链表中查找元素
int selectElem(LinkList L,ElemType elem){
    
    LinkList p = L->next;
    int i = 1;
    while (p) {
        if (p->data == elem) {
            return i;
        }
        
        i++;
        p = p->next;
    }
    
    return  -1;
}

//5.6.2 在双向链表中更新结点
Status replaceLinkList(LinkList *L,int index,ElemType newElem){
    LinkList p = (*L)->next;
    
    for (int i = 1; i < index; i++) {
        p = p->next;
    }
    
    p->data = newElem;
    return OK;
}

int main(int argc, const char * argv[]) {
    // insert code here...
    printf("Hello, World!\n");
    
    Status iStatus = 0;
    LinkList L;
    int temp,item,e;
    
    iStatus =  createLinkList(&L);
    printf("iStatus = %d\n",iStatus);
    printf("链表创建成功,打印链表:\n");
    display(L);
    
    printf("请输入插入的位置\n");
    scanf("%d %d",&temp,&item);
    iStatus = ListInsert(&L, temp, item);
    printf("插入数据,打印链表:\n");
    display(L);
    
    printf("请输入插入的位置\n");
    scanf("%d %d",&temp,&item);
    iStatus = ListInsert(&L, temp, item);
    printf("插入数据,打印链表:\n");
    display(L);
    
    printf("请输入插入的位置\n");
    scanf("%d %d",&temp,&item);
    iStatus = ListInsert(&L, temp, item);
    printf("插入数据,打印链表:\n");
    display(L);
    
    printf("请输入删除的位置\n");
    scanf("%d",&temp);
    iStatus = ListDelete(&L, temp, &e);
    printf("删除元素: 删除位置为%d,data = %d\n",temp,e);
    printf("删除操作之后的,双向链表:\n");
    display(L);
    
    printf("请输入你要删除的内容\n");
    scanf("%d",&temp);
    iStatus = LinkListDeletVAL(&L, temp);
    printf("删除指定data域等于%d的结点,双向链表:\n",temp);
    display(L);

    printf("请输入你要查找的内容\n");
     scanf("%d",&temp);
    ElemType index = selectElem(L, temp);
    printf("在双向链表中查找到数据域为%d的结点,位置是:%d\n",temp,index);

    printf("请输入你要更新的结点以及内容\n");
    scanf("%d %d",&temp,&item);
    iStatus = replaceLinkList(&L, temp, item);
    printf("更新结点数据后的双向链表:\n");
    display(L);

    return 0;
}

⭐️双向循环链表

①、线性表 - 双向循环链表的介绍

双向循环链表特点是:
最后一个结点的next指向链表的指针(*L)

1.1 流程图 - 双向循环链表 - 整个链表结构

请添加图片描述

②、线性表 - 双向循环链表 创建

2. 🌰案例 - 双向循环链表 创建 代码实现

//6.1 双向循环链表初始化
Status creatLinkList(LinkList *L){
    
    *L = (LinkList)malloc(sizeof(Node));
    if (*L == NULL) {
        return ERROR;
    }
    
    (*L)->next = (*L);
    (*L)->prior = (*L);
    
    //新增数据
    LinkList p = *L;
    for(int i=0; i < 10;i++){
        
        //1.创建1个临时的结点
        LinkList temp = (LinkList)malloc(sizeof(Node));
        temp->data = i;
        
        //2.为新增的结点建立双向链表关系
        //① temp 是p的后继
        p->next = temp;
        //② temp 的前驱是p
        temp->prior = p;
        //③ temp的后继是*L
        temp->next = (*L);
        //④ p 的前驱是新建的temp
        p->prior = temp;
        //⑤ p 要记录最后的结点的位置,方便下一次插入
        p = p->next;
        
    }
    
    return OK;
   
}

③、线性表 - 双向循环链表 遍历

3. 🌰案例 - 双向循环链表 遍历 代码实现

//6.3 遍历双向循环链表
Status Display(LinkList L){
    
    if (L == NULL) {
        printf("打印的双向循环链表为空!\n\n");
        return ERROR;
    }
    printf("双向循环链表内容:  ");
    
    LinkList p = L->next;
    while (p != L) {

        printf("%d  ",p->data);
        p = p->next;
    }
    printf("\n\n");
    return OK;
}

④、线性表 - 双向循环链表 插入

双向循环链表我们没有创建头结点
双向循环我们创建了头结点
因为有了头结点
我们插入的时候 不需要判断是不是要添加到首元节点
所以我们根本就不需要去判断*L 头部
尾部还是要判断的

🌰说明步骤
比如在AB之间插入C
A表示(变量p)
C表示(temp)

  1. 先判断索引值的异常 也就是在链表哪个位置进行插入
  2. 先找到 A(变量p)
  3. 创建C结点(temp)
  4. 将C结点的(next) 指向 B(p->next)
  5. 将B结点（p->next）的前驱(p->next->prior)指向C
  6. 将A结点(变量p)next 指向C结点(temp)
  7. 将C结点的前驱(temp->prior) 指向A结点(变量p)

4.1 结果图 - 双向循环链表 插入

请添加图片描述

4. 🌰案例 - 双向循环链表 插入 代码实现

//6.2 双向循环链表插入元素
/*当插入位置超过链表长度则插入到链表末尾*/
Status LinkListInsert(LinkList *L, int index, ElemType e){
   
    //1. 创建指针p,指向双向链表头
    LinkList p = (*L);
    int i = 1;
    
    //2.双向循环链表为空,则返回error
    if(*L == NULL) return ERROR;
   
    //3.找到插入前一个位置上的结点p
    while (i < index && p->next != *L) {
        p = p->next;
        i++;
    }
    
    //4.如果i>index 则返回error
    if (i > index)  return ERROR;
    
    //5.创建新结点temp
    LinkList temp = (LinkList)malloc(sizeof(Node));
    
    //6.temp 结点为空,则返回error
    if (temp == NULL) return ERROR;
    
    //7.将生成的新结点temp数据域赋值e.
    temp->data = e;
    
    //8.将结点temp 的前驱结点为p;
    temp->prior = p;
    //9.temp的后继结点指向p->next;
    temp->next = p->next;
    //10.p的后继结点为新结点temp;
    p->next = temp;
    
    //如果temp 结点不是最后一个结点
    if (*L != temp->next) {
        
        //11.temp节点的下一个结点的前驱为temp 结点
        temp->next->prior = temp;
    }else{

        (*L)->prior = temp;
        
    }
    
    return OK;
}

⑤、线性表 - 双向循环链表 删除

逻辑基本上是和双向链表基本相似
考虑删除只有一个结点的情况(此时应该还有2个结点 包含头节点)

5.1 结果图 - 双向循环链表 删除

请添加图片描述

5. 🌰案例 - 双向循环链表 删除 代码实现

//6.4 双向循环链表删除结点
Status LinkListDelete(LinkList *L,int index,ElemType *e){
    
    int i = 1;
    LinkList temp = (*L)->next;
    
    if (*L == NULL) {
        return  ERROR;
    }
    
    //①.如果删除到只剩下首元结点了,则直接将*L置空;
    if(temp->next == *L){
        free(*L);
        (*L) = NULL;
        return OK;
    }
    
    //1.找到要删除的结点
    while (i < index) {
        temp = temp->next;
        i++;
    }

    //2.给e赋值要删除结点的数据域
    *e = temp->data;
    
    //3.修改被删除结点的前驱结点的后继指针 图1️⃣
    temp->prior->next = temp->next;
    //4.修改被删除结点的后继结点的前驱指针 图2️⃣
    temp->next->prior = temp->prior;
    //5. 删除结点temp
    free(temp);
    
    return OK;
    
}

💡⑤、双向循环链表end - 双向链表 - 综合代码

#include <stdio.h>
#include "string.h"
#include "ctype.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"

#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OK 1

#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */

//定义结点
typedef struct Node{
    ElemType data;
    struct Node *prior;
    struct Node *next;
}Node;

typedef struct Node * LinkList;

//6.1 双向循环链表初始化
Status creatLinkList(LinkList *L){
    
    *L = (LinkList)malloc(sizeof(Node));
    if (*L == NULL) {
        return ERROR;
    }
    
    (*L)->next = (*L);
    (*L)->prior = (*L);
    
    //新增数据
    LinkList p = *L;
    for(int i=0; i < 10;i++){
        
        //1.创建1个临时的结点
        LinkList temp = (LinkList)malloc(sizeof(Node));
        temp->data = i;
        
        //2.为新增的结点建立双向链表关系
        //① temp 是p的后继
        p->next = temp;
        //② temp 的前驱是p
        temp->prior = p;
        //③ temp的后继是*L
        temp->next = (*L);
        //④ p 的前驱是新建的temp
        p->prior = temp;
        //⑤ p 要记录最后的结点的位置,方便下一次插入
        p = p->next;
        
    }
    
    return OK;
   
}

//6.2 双向循环链表插入元素
/*当插入位置超过链表长度则插入到链表末尾*/
Status LinkListInsert(LinkList *L, int index, ElemType e){
   
    //1. 创建指针p,指向双向链表头
    LinkList p = (*L);
    int i = 1;
    
    //2.双向循环链表为空,则返回error
    if(*L == NULL) return ERROR;
   
    //3.找到插入前一个位置上的结点p
    while (i < index && p->next != *L) {
        p = p->next;
        i++;
    }
    
    //4.如果i>index 则返回error
    if (i > index)  return ERROR;
    
    //5.创建新结点temp
    LinkList temp = (LinkList)malloc(sizeof(Node));
    
    //6.temp 结点为空,则返回error
    if (temp == NULL) return ERROR;
    
    //7.将生成的新结点temp数据域赋值e.
    temp->data = e;
    
    //8.将结点temp 的前驱结点为p;
    temp->prior = p;
    //9.temp的后继结点指向p->next;
    temp->next = p->next;
    //10.p的后继结点为新结点temp;
    p->next = temp;
    
    //如果temp 结点不是最后一个结点
    if (*L != temp->next) {
        
        //11.temp节点的下一个结点的前驱为temp 结点
        temp->next->prior = temp;
    }else{

        (*L)->prior = temp;
        
    }
    
    return OK;
}


//6.3 遍历双向循环链表
Status Display(LinkList L){
    
    if (L == NULL) {
        printf("打印的双向循环链表为空!\n\n");
        return ERROR;
    }
    printf("双向循环链表内容:  ");
    
    LinkList p = L->next;
    while (p != L) {

        printf("%d  ",p->data);
        p = p->next;
    }
    printf("\n\n");
    return OK;
}

//6.4 双向循环链表删除结点
Status LinkListDelete(LinkList *L,int index,ElemType *e){
    
    int i = 1;
    LinkList temp = (*L)->next;
    
    if (*L == NULL) {
        return  ERROR;
    }
    
    //①.如果删除到只剩下首元结点了,则直接将*L置空;
    if(temp->next == *L){
        free(*L);
        (*L) = NULL;
        return OK;
    }
    
    //1.找到要删除的结点
    while (i < index) {
        temp = temp->next;
        i++;
    }

    //2.给e赋值要删除结点的数据域
    *e = temp->data;
    
    //3.修改被删除结点的前驱结点的后继指针 图1️⃣
    temp->prior->next = temp->next;
    //4.修改被删除结点的后继结点的前驱指针 图2️⃣
    temp->next->prior = temp->prior;
    //5. 删除结点temp
    free(temp);
    
    return OK;
    
}

int main(int argc, const char * argv[]) {
    // insert code here...
    printf("Hello, World!\n");
    
    LinkList L;
    Status iStatus;
    ElemType temp,item;
    
    iStatus = creatLinkList(&L);
    printf("双向循环链表初始化是否成功(1->YES)/ (0->NO):  %d\n\n",iStatus);
    Display(L);
    
    printf("输入要插入的位置和数据用空格隔开：");
    scanf("%d %d",&temp,&item);
    iStatus = LinkListInsert(&L,temp,item);
    Display(L);

    printf("输入要删除位置：");
    scanf("%d",&temp);
    iStatus = LinkListDelete(&L, temp, &item);
    printf("删除链表位置为%d,结点数据域为:%d\n",temp,item);
    Display(L);

    
    return 0;
}
宇夜iOS
关注
  • 2
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
2007.08.22双向链表（前插操作，删除操作）
blacklord的专栏
08-22 3728
双向链表循环单链表的出现，虽然能够实现从任一结点出发沿着链能找到其前驱结点，但时间耗费是O（n）。如果希望从表中快速确定某一个结点的前驱，另一个解决方法就是在单链表的每个结点里再增加一个指向其前驱的指针域prior。这样形成的链表中就有两条方向不同的链，我们可称之为双（向）链表（Double Linked List）。双链表的结构定义如下：
数据结构——双向循环链表
weixin_43850474的博客
09-27 2419
双链表的结构 解析： 每一个结点都有一个数据域，两个指针域。其中一个指针域指向它的直接后继，另外一个指向它的直接前驱。 对于头结点来说，它的直接前驱是最后一个结点；对于最后一个结点来说，它的直接后继是头结点。所以对于双向链表来说，它的判空条件是head->next=head或者是head->prev=head 下图为一个带头结点的空双链表 双链表基本操作的实现 （1）插入 1....
循环双链表
m0_68805093的博客
07-30 308
循环双链表（Circular Doubly Linked List）是一种常见的数据结构，它是双向链表的一种扩展形式。和双向链表一样，循环双链表中的每个节点都包含两个指针，一个指向前一个节点，另一个指向后一个节点。不同之处在于，循环双链表的最后一个节点的后继指针指向头节点，头节点的前驱指针指向最后一个节点，从而形成一个循环。循环双链表可以在任意位置高效地插入和删除节点，并且可以双向遍历整个链表。int data;//存储数据//指向前后的指针。
双向循环链表简单的插入、删除、修改以及查找功能的实现
super_marie的博客
05-22 1427
1“`include include define T 1define F 0typedef int ElementType; typedef int Boolean; typedef struct node* Node;struct node //定义双向的结构体 { struct node* prior; ElementType value; struct n
初夏小谈：双向循环链表增、删、查、改基本操作（完整版）
Scissors_初夏的博客
12-09 981
                                       带头结点的双向循环链表 我之前对链表进行操作时一直是用头指针的方式，今天所说的链表是用头结点的方式。它们二者其实区别不是很大。共同点都是指向链表的第一个结点。不同点是：头结点的存储数据的内存里面可以存储链表信息，也可以什么都不存。而头指针只能用于指向链表第一个结点，它不能存储其它数据，因为它只有存储指针的内存。2.就...
链表-使用PHP实现的双向链表数据结构.zip
最新发布
03-13
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。...这有助于解决需要高效插入、删除和遍历操作的场景，例如在数据库操作、数据解析或图形算法中。
c语言数组指定位置插入和删除-玩转C语言链表，单链表双向链表的建立遍历插入删除... 数组和链表.pdf
04-18
本文主要讲解了C语言中数组和链表的概念及操作，包括数组指定位置插入和删除、链表的结构、静态链表和动态链表、单链表的建立和遍历、双向链表的概念、循环链表的概念等。同时也涉及到了链表的实战应用和拓展思维。 ...
C语言之航空信息查询系统-使用双向循环链表实现系统的增删改查操作
09-20
在本项目中，我们利用C语言构建了一个航空信息查询系统，该系统的核心数据结构是双向循环链表。双向循环链表是一种特殊的链式存储结构，它允许我们在链表的两个方向上进行遍历，这对于执行增删改查操作非常有用。...
JavaScript数据结构之双向链表和双向循环链表的实现
10-18
在JavaScript中，数据结构是构建复杂程序的基础，其中双向链表和双向循环链表是两种重要的线性数据结构。本文将深入探讨这两种链表的实现原理，并通过代码示例进行详细解析。 首先，双向链表（Doubly Linked List）...
【Java数据结构与算法】双向链表
12-21
在计算机科学中，数据结构是组织、存储和处理数据的方式，而算法是解决问题或执行特定任务的步骤。本文主要讨论的是双向链表，这是一种重要的线性数据结构，它弥补了单向链表的一些缺点。 双向链表是一种链式存储...
双向循环链表
weixin_53946312的博客
04-17 3245
双向循环链表 一、什么是双向链表？双向循环链表？ 1.双向链表指的是构成链表的每个结点中设立两个指针域：一个指向其直接前驱的指针域prev，一个指向其直接后继的指针域next。这样形成的链表中有两个方向不同的链，故称为双向链表。 2.双向循环链表将双向链表的头结点和尾结点链接起来也能构成循环链表，其称为双向循环链表。 二、双向循环链表的实现 1、结构 typedef int LTDataType; typedef struct ListNode { struct ListNode* next; stru
实现循环双链表各种基本运算的算法
xiezhi123456的博客
01-12 2448
#include &lt;stdio.h&gt; #include &lt;malloc.h&gt; #include &lt;stdbool.h&gt; typedef int ElemType; typedef struct DNode {     ElemType data;//数据域     struct DNode *prior;//指向前驱结点     struct DNode *n...
数据结构双向链表学习
fengjuju的博客
05-02 1259
目录 一.双链表 二.代码展示 1.双向链表的定义 2.双向链表的初始化 3.双向链表在指定位置插入新元素 4.双向链表删除指定元素 5.找到指定元素的位置 6.打印链表长度 7.双向链表的整表删除 8.返回指定结点的地址 9.完整代码 10.样例测试输出 三.总结 一.双链表 双链表对比于单链表添加了一个前驱指针域，优势是可以实现双向遍历，而单链表只能从头结点开始遍历。 学生作业，大佬路过有误请指正。 二.代码展示 1.双向链表的定义 /** * Do
数据结构 P36-37 算法实现 双向循环链表的插入与删除
bo_1997_2017的博客
10-11 783
/*双向链表的插入与删除*/ #include using namespace std; struct node                                  //双向链表的节点 { int date; node *next;                              //指向后一个节点 node *prior;
双向链表的添加元素与删除元素
vivian233的博客
03-13 556
/** * @author Eightn0 * @create 2021-03-13 20:36 * 双向链表：一个字段存放数据，两个字段存放指针，一个指针指向后面的节点，另一个指针指向前面的节点 * llink-data-rlink * 插入：在第一个位置插入：将新节点的右链接指向原表的第一个节点，左链接指向null * 将原表第一个节点的左链接指向新节点 * 将原表表头指针head指向新节点 * .
【链表】双向循环带头链表-增-删-查(C语言)
半生瓜のblog
06-01 412
单链表存在的缺陷： 不能从后往前走, 找不到他的前驱, 指定位置 删除 增加 尾删 都要找前一个，时间复杂度都是O(n) 针对上面的这些缺陷的解决方案——双向链表。 双向循环带头链表带头双向循环链表结构体创建创建结点初始化销毁打印尾插头插头删尾删查找位置删除pos位置的值在pos前插入x返回链表的结点数量判断链表是否为空优化总结 实际中要实现的链表的结构非常多样，以下情况组合起来就有8种链表结构： 单向、双向 带头、不带头——带哨兵位的头结点，这个结点不存储有效数据，好处是什么？尾插的判断更方便简.
双向循环链表涉及双向指针的基本操作(C语言)
weixin_30763455的博客
12-20 1037
　　链表大概分为有无头指针，有无尾指针，是否循环，单向还是双向， 这些都很简单，前提是你要把指针和单链表理解透彻。这些都是基于单链表 的变形，要根据实际问题，选择链表的类型。 　　头指针的指针域储存着储存头节点的地址，其数据域我们不使用。 尾指针同理。 　　循环链表的最后一个节点指向头节点(如果有头指针，则是指向头指针)， 非循环链表的最后一个节点指向NUll。 　　单向链...
带头节点的双向循环链表的基本操作
热门推荐
Ksaila的博客
08-30 1万+
双向循环链表： 双向循环链表中每一个节点都有一个直接的前驱和一个直接的后继 双向循环链表中的节点有两个指针域和一个存放数据的地方，两个指针域一个存放下一个节点的地址，一个存放前一个指针的地址 下面是双向循环链表的基本操作： CircularList.h #ifndef _LINKLIST_H_ #define _LINKLIST_H_ #include&lt;stdlib.h...
2018-w4rd3n-数据结构课设1
08-08
为了满足这些需求，我选择了双向循环链表作为数据结构的基础，因为双向循环链表在插入、删除和查询等操作上都有良好的性能表现。 接着，我进行了数据结构的设计。每个节点包含了商铺编号、商铺名、信誉度、商品名称...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

宇夜iOS

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值