双向链表

最新推荐文章于 2024-08-03 09:58:03 发布
最新推荐文章于 2024-08-03 09:58:03 发布
阅读量1.1k 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 双链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GailyYelp/article/details/67709082
版权

双向链表简介和举例解析

这里写图片描述

双链表结构体的定义1：
结构体：这里写图片描述
主函数中：这里写图片描述
调用函数中：这里写图片描述

双链表结构体的定义2：
结构体：这里写图片描述
主函数中：这里写图片描述
调用函数中：这里写图片描述

这里写图片描述

头插法：这里写图片描述

尾插法：这里写图片描述

这里写图片描述

双向链表代码1

#include <stdio.h>
#include <malloc.h>
#define true 1
#define false 0
typedef int bool;
typedef int ElemType;
typedef struct DNode        //定义双链表结点类型
{
    ElemType data;
    struct DNode *prior;    //指向前驱结点
    struct DNode *next;     //指向后继结点
} DLinkList;
void CreateListF(DLinkList *L, ElemType a[], int n);//头插法建双链表
void CreateListR(DLinkList *L, ElemType a[], int n);//尾插法建双链表
DLinkList *InitList();
//void InitList(DLinkList *L); //初始化双链表
void DestroyList(DLinkList *L); //销毁双链表
bool ListEmpty(DLinkList *L); //判断链表是否为空
int ListLength(DLinkList *L); //求链表的长度
void DispList(DLinkList *L); //输出链表
bool GetElem(DLinkList *L, int i, ElemType *e); //获取节点的值
int LocateElem(DLinkList *L, ElemType e); //查找一个节点
bool ListInsert(DLinkList *L, int i, ElemType e);//插入一个节点
bool ListDelete(DLinkList *L, int i, ElemType *e); //删除一个节点

int main()
{
    DLinkList *A;
    int e;
    ElemType a[] = { 1, 3, 2, 9, 0, 4, 5, 6, 7, 8 };
    A=InitList();
    CreateListR(A, a, 10);
    printf("第三个节点的值是什么：");
    GetElem(A, 3, &e);
    printf("%d", e);
    printf("\n链表的长度: %d\n", ListLength(A));
    printf("你要查找哪个值？");
    int p;
    scanf("%d", &p);
    printf("是第%d个节点", LocateElem(A,p));
    printf("\n插入的节点，插入的位置：");
    int n, v;
    scanf("%d%d", &n, &v);
    ListInsert(A, n, v);
    printf("After Insert: ");
    DispList(A);
    DestroyList(A);
    system("pause");
    return 0;
}

DLinkList *InitList()
{
    DLinkList *L;
    L = (DLinkList *)malloc(sizeof(DLinkList));   //创建头结点
    L->prior = L->next = NULL;
    return L;

}

void CreateListF(DLinkList *L, ElemType a[], int n)
//头插法建双链表
{
    DLinkList *s;
    int i;
    //L = (DLinkList *)malloc(sizeof(DLinkList));   //创建头结点
    //L->prior = L->next = NULL;
    for (i = 0; i<n; i++)
    {
        s = (DLinkList *)malloc(sizeof(DLinkList));//创建新结点
        s->data = a[i];
        s->next = L->next;            //将*s插在原开始结点之前,头结点之后
        if (L->next != NULL) L->next->prior = s;
        L->next = s;
        s->prior = L;
    }
}
void CreateListR(DLinkList *L, ElemType a[], int n)
//尾插法建双链表
{
    DLinkList *s, *r;
    int i;
    //L = (DLinkList *)malloc(sizeof(DLinkList));   //创建头结点
    //L->prior = L->next = NULL;
    r = L;                    //r始终指向终端结点,开始时指向头结点
    for (i = 0; i<n; i++)
    {
        s = (DLinkList *)malloc(sizeof(DLinkList));//创建新结点
        s->data = a[i];
        r->next = s;
        s->prior = r; //将*s插入*r之后
        r = s;
    }
    r->next = NULL;           //终端结点next域置为NULL
}
//void InitList(DLinkList **L)
//{
//  (*L) = (DLinkList *)malloc(sizeof(DLinkList));   //创建头结点
//  (*L)->prior = (*L)->next = NULL;
//}
void DestroyList(DLinkList *L)
{
    DLinkList *p = L, *q = p->next;
    while (q != NULL)
    {
        free(p);
        p = q;
        q = p->next;
    }
    free(p);
}
bool ListEmpty(DLinkList *L)
{
    return(L->next == NULL);
}
int ListLength(DLinkList *L)
{
    DLinkList *p = L;
    int i = 0;
    while (p->next != NULL)
    {
        i++;
        p = p->next;
    }
    return(i);
}
void DispList(DLinkList *L)
{
    DLinkList *p = L->next;
    while (p != NULL)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}
bool GetElem(DLinkList *L, int i, ElemType *e)
{
    int j = 0;
    DLinkList *p = L;
    while (j<i && p != NULL)
    {
        j++;
        p = p->next;
    }
    if (p == NULL)
        return false;
    else
    {
        *e = p->data;
        return true;
    }
}
int LocateElem(DLinkList *L, ElemType e)
{
    int n = 1;
    DLinkList *p = L->next;
    while (p != NULL && p->data != e)
    {
        n++;
        p = p->next;
    }
    if (p == NULL)
        return(0);
    else
        return(n);
}
bool ListInsert(DLinkList *L, int i, ElemType e)
{
    int j = 0;
    DLinkList *p = L, *s;
    while (j<i - 1 && p != NULL)
    {
        j++;
        p = p->next;
    }
    if (p == NULL)    //未找到第i-1个结点
        return false;
    else            //找到第i-1个结点*p
    {
        s = (DLinkList *)malloc(sizeof(DLinkList));   //创建新结点*s
        s->data = e;
        s->next = p->next;        //将*s插入到*p之后
        if (p->next != NULL) p->next->prior = s;
        s->prior = p;
        p->next = s;
        return true;
    }
}
bool ListDelete(DLinkList *L, int i, ElemType *e)
{
    int j = 0;
    DLinkList *p = L, *q;
    while (j<i - 1 && p != NULL)
    {
        j++;
        p = p->next;
    }
    if (p == NULL)                //未找到第i-1个结点
        return false;
    else                        //找到第i-1个结点*p
    {
        q = p->next;              //q指向要删除的结点
        if (q == NULL)
            return false;       //不存在第i个结点
        *e = q->data;
        p->next = q->next;        //从单链表中删除*q结点
        if (p->next != NULL) p->next->prior = p;
        free(q);                //释放*q结点
        return true;
    }
}

双向链表代码2

#include<stdio.h>  
#include<stdlib.h>  
#include<malloc.h>  

typedef int bool;
typedef char ElemType;
typedef struct DuLNode
{
    ElemType data;
    struct DuLNode *prior;
    struct DuLNode *next;

}DuLinkList;


int DuLink_ListInsertR(DuLinkList *L, ElemType e)//采用尾插法插入元素  
{
    DuLinkList *p = L, *q;
    while (p->next != NULL)
    {
        p = p->next;
    }
    q = (DuLinkList *)malloc(sizeof(DuLinkList));
    q->data = e;
    q->prior = p;
    p->next = q;
    q->next = NULL;
    return 1;
}

void DuLink_DispList(DuLinkList *L)
{
    DuLinkList *p;
    p = L->next;
    while (p != NULL)
    {
        printf("%c", p->data);
        p = p->next;
    }
    printf("\n");
}

void DuLink_ListLength(DuLinkList *L)
{
    DuLinkList *p;
    p = L;
    int i = 0;
    while (p->next != NULL)
    {
        i++;
        p = p->next;
    }
    printf("长度为: %d\n", i);

}

bool DuLink_ListEmpty(DuLinkList *L)
{
    return(L->next == NULL);
}


bool DuLink_GetElem(DuLinkList *L, int i)
{
    int j = 0;
    DuLinkList *p=NULL;
    p = L;
    while (j<i &&p != NULL)
    {
        j++;
        p = p->next;
    }
    if (p == NULL)
        printf("ERROR");
    else
    {
        printf("%c\n", p->data);
    }
}

int DuLink_LocateElem(DuLinkList *L, ElemType e)
{
    int i = 1;
    DuLinkList *p = L->next;
    while (p != NULL&&p->data != e)
    {
        p = p->next;
        i++;
    }
    if (p == NULL)
        return 0;
    else
    {

        return i;
    }
}

void DuLink_ListInsert(DuLinkList *L, int i, ElemType e)
{
    DuLinkList *p, *q;
    p = L;
    int j = 0;
    while (j<i&&p != NULL)
    {
        j++;
        p = p->next;
    }
    p = p->prior;
    q = (DuLinkList *)malloc(sizeof(DuLinkList));
    q->data = e;
    q->next = p->next;
    q->prior = p;
    p->next = q;
}

int DuLink_ListDestroy(DuLinkList *L, int i)
{
    int j = 0;
    DuLinkList *p, *q;
    p = L;
    while (j<i&&p != NULL)
    {
        j++;
        p = p->next;
    }
    if (p == NULL)
        return 0;
    else
    {
        q = p;
        p = p->prior;
        p->next = q->next;
        free(q);
        return 1;
    }
}

//void DuLink_DestroyList(DuLinkList *L)
//{
//  DuLinkList *p=L, *q=p->next;
//  
//  while (q != NULL)
//  {
//      free(q);
//      p = q;
//      q = q->next;
//  }
//  free(p);
//}

void DuLink_InitList(DuLinkList **L)
{

    (*L) = (DuLinkList *)malloc(sizeof(DuLinkList));
    (*L)->prior = NULL;
    (*L)->next = NULL;
    //return L;
}

int main()
{
    DuLinkList *h=NULL;
    ElemType e;
    printf("双链表的基本运算如下:\n");
    DuLink_InitList(&h);
    printf("初始化双链表h\n");
    printf("依次采用尾插入法插入a,b,c,d,e元素\n");
    DuLink_ListInsertR(h, 'a');
    DuLink_ListInsertR(h, 'b');
    DuLink_ListInsertR(h, 'c');
    DuLink_ListInsertR(h, 'd');
    DuLink_ListInsertR(h, 'e');
    printf("输出双链表h:\n");
    DuLink_DispList(h);
    printf("双链表h长度");
    DuLink_ListLength(h);
    printf("判断双链表h是为空\n");
    DuLink_ListEmpty(h);
    printf("输出双链表h的第3个元素\n");
    DuLink_GetElem(h, 3);
    printf("元素a的位置=%d\n", DuLink_LocateElem(h, 'a'));
    printf("在第4个元素插入f元素\n");
    DuLink_ListInsert(h, 4, 'f');
    printf("输出双链表h:");
    DuLink_DispList(h);
    printf("删除h的第3个元素\n");
    DuLink_ListDestroy(h, 3);
    printf("输出双链表h:");
    DuLink_DispList(h);
    /*printf("释放双链表h\n");
    DuLink_DestroyList(h);*/
    system("pause");
}
不想变蠢的蠢
关注
专栏目录
Python单向链表和双向链表原理与用法实例详解
09-20
在Python中，我们可以自定义链表结构来实现单向链表和双向链表。 单向链表（Single Linked List）的特点是每个节点只包含一个指向下一个节点的引用。在单向链表中，遍历只能从头节点开始，按顺序访问每个节点，无法...
双链表
weixin_30654583的博客
09-14 59
今天，我们一起用C++写一个双链表，具体代码如下：DoubleList.h具体内容如下：#include "NodeList.h" template<typename Type> class DoublyList{ public: DoublyList() :head(new ListNode<Type>()){ //the head node poi...
数据结构：双向链表
最新发布
2401_86551514的博客
08-03 821
这里的“带头”跟“头节点”是两个概念，带头链表里的头节点，实际为“哨兵位”，哨兵位节点不存储任何有效元素，只是站在这里“放哨 的” ，存在的意义： 遍历循环链表避免死循环。虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：单链表和双向带头循环链表，上一篇我们已经讲了单链表，今天就来了解一下双向链表并将其实现。顺序表和链表我们都学了，两者各有各的优缺点，根据需求的不通，运用在不同的场景。本篇的内容就到这里了，希望对各位有帮助，如果有错误欢迎指出。还是老样子，在头文件里写出我们需要功能的函数名。
操作系统课设-线程安全的双向链表
04-25
操作系统课程设计中实现线程安全的双向链表是一项重要的实践任务，这涉及到多线程编程、数据结构以及并发控制等核心知识点。在这个项目中，我们主要关注如何在多线程环境下构建一个能够正确操作（如插入、删除）而不...
创建双向链表_双向链表_
09-30
双向链表是一种特殊类型的数据结构，与常见的单向链表相比，它具有更丰富的操作能力，可以支持前后两个方向的遍历。本篇文章将深入探讨如何创建双向链表以及其在增加和删除操作中的应用。 双向链表的每个节点不仅...
双向链表.cpp 双向链表类定义及测试代码 c++
12-02
双向链表类定义及测试文件 对应于数据机构与算法分析（c++版）第三版或第二版 Clifford A.Shaffer 重庆大学使用教材
stm32f103 双向链表
08-16
在这个项目中，我们讨论的是如何在STM32F103上实现一个双向链表的数据结构。双向链表是一种特殊的数据结构，它允许我们在列表中的节点之间进行前向和后向的移动，这在处理动态数据集合时非常有用。 首先，我们要...
无头双向链表方法
yanweiding的博客
10-29 123
public class DoubleLinkedList { //头插法 public void addFirst(int data); //尾插法 public void addLast(int data); //任意位置插入,第一个数据节点为0号下标 public boolean addIndex(int index,int data); //查找是否包含关键字key是否在单链表当中 public boolean contains(int key); //删除第一次出现关键字为key的节点 publi
双向链表数据管理
"多重双向链表的实现及操作" 多重双向链表是一种复杂的数据结构，它不仅包含元素节点，还包含多个指向不同属性的链接。在这个实现中，链表用于存储具有姓名、性别、信仰和职务等信息的员工数据。链表的每个节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值