循环双链表的代码实现

已于 2024-04-03 13:31:52 修改
阅读量100 收藏
点赞数
分类专栏： 数据结构设计与应用 文章标签： 数据结构 c语言 java 链表
于 2023-08-04 07:49:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55094971/article/details/128561186
版权

        循环双链表，是一种链式存储结构的线性表，它具有两个指针域（一前一后分别是指向当前结点的直接前驱和直接后继），一个数据域。它与普通的双链表不同的是，头结点的直接前驱不再是NULL，而是该双链表的尾结点。而尾结点的直接后继也不再是BULL，而是该双链表的头结点。除了判断表是否为空、遍历表元素等操作的判断条件有所变化其余的操作（如插入，删除等等）和一般的双链表一样。

        以下就是循环双链表的代码实现：

        C语言（CircularDoubleLinkedList）:

#ifndef CIRCULARDOUBLELINKEDLIST_H_INCLUDED
#define CIRCULARDOUBLELINKEDLIST_H_INCLUDED

typedef int ElemType;
typedef struct Node
{
    ElemType elem;
    struct Node *prior;
    struct Node *next;
}LNode,*LinkedList;
void InitList(LinkedList *L)
{
    (*L)=(LNode*)malloc(sizeof(LNode));
    (*L)->next=(*L);
    (*L)->prior=(*L);
}
void DestroyList(LinkedList *L)
{
    LNode *p=(*L),*clc;
    while(p->next!=(*L))
    {
        p=p->next;
    }
    while(p!=(*L))
    {
        clc=p;
        p=clc->prior;
        clc->prior->next=clc->next;
        clc->next->prior=clc->prior;
        free(clc);
        clc=NULL;
    }
    free(*L);
    (*L)=NULL;
}
void ClearList(LinkedList *L)
{
    LNode *p=(*L),*clc;
    while(p->next!=(*L))
    {
        p=p->next;
    }
    while(p!=(*L))
    {
        clc=p;
        p=clc->prior;
        clc->prior->next=clc->next;
        clc->next->prior=clc->prior;
        free(clc);
        clc=NULL;
    }
}
int ListEmpty(LinkedList *L)
{
    LNode *p=(*L);
    if(p->next==(*L))
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
int ListLength(LinkedList *L)
{
    LNode *p=(*L);
    int i=0;
    while(p->next!=(*L))
    {
        i++;
        p=p->next;
    }
    return i;
}
ElemType GetElem(LinkedList *L,int index)
{
    if(index<0||index>=ListLength(L))
    {
        return -1;
    }
    int i=0;
    LNode *p=(*L)->next;
    while(i<index)
    {
        i++;
        p=p->next;
    }
    return p->elem;
}
int LocateElem(LinkedList *L,ElemType elem)
{
    int i=0;
    LNode *p=(*L)->next;
    while(p!=(*L))
    {
        if(p->elem==elem)
        {
            return i;
        }
        i++;
        p=p->next;
    }
    return -1;
}
ElemType PriorElem(LinkedList *L,ElemType elem)
{
    LNode *p=(*L)->next;
    while(p!=(*L))
    {
        if(p->elem==elem)
        {
            if(LocateElem(L,elem)==0)
            {
                return p->prior->prior->elem;
            }
            return p->prior->elem;
        }
        p=p->next;
    }
    return -1;
}
ElemType NextElem(LinkedList *L,ElemType elem)
{
    LNode *p=(*L)->next;
    while(p!=(*L))
    {
        if(p->elem==elem)
        {
            if(LocateElem(L,elem)==ListLength(L)-1)
            {
                return p->next->next->elem;
            }
            return p->next->elem;
        }
        p=p->next;
    }
    return -1;
}
void addFirst(LinkedList *L,ElemType elem)
{
    LNode *s,*p=(*L);
    s=(LNode*)malloc(sizeof(LNode));
    s->elem=elem;
    s->next=p->next;
    s->next->prior=s;
    s->prior=p;
    p->next=s;
}
void addAfter(LinkedList *L,ElemType elem)
{
    LNode *p=(*L),*s;
    s=(LNode*)malloc(sizeof(LNode));
    s->elem=elem;
    while(p->next!=(*L))
    {
        p=p->next;
    }
    s->next=p->next;
    s->next->prior=s;
    s->prior=p;
    s->prior->next=s;
}
int ListInsert(LinkedList *L,int index,ElemType elem)
{
    if(index<0||index>ListLength(L))
    {
        return -1;
    }
    else
    {
        LNode *p=(*L),*s;
        s=(LNode*)malloc(sizeof(LNode));
        s->elem=elem;
        int i=0;
        while(i<index)
        {
            p=p->next;
            i++;
        }
        s->next=p->next;
        s->next->prior=s;
        s->prior=p;
        s->prior->next=s;
        return 1;
    }
}
int ListDelete(LinkedList *L,int index)
{
    if(index<0||index>=ListLength(L))
    {
        return -1;
    }
    else
    {
        int i=0;
        LNode *p=(*L)->next,*del;
        while(i<index)
        {
            p=p->next;
            i++;
        }
        del=p;
        del->prior->next=del->next;
        del->next->prior=del->prior;
        free(del);
        del=NULL;
        return 1;
    }
}
void TraverseList(LinkedList *L)
{
    LNode *p=(*L)->next;
    while(p!=(*L))
    {
        printf("%d\t",p->elem);
        p=p->next;
    }
    printf("\n");
}
void TraverseListByReverseOrder(LinkedList *L)
{
    LNode *p=(*L)->next;
    while(p->next!=(*L))
    {
        p=p->next;
    }
    while(p!=(*L))
    {
        printf("%d\t",p->elem);
        p=p->prior;
    }
    printf("\n");
}

#endif // CIRCULARDOUBLELINKEDLIST_H_INCLUDED

        Java语言:

package DataStructure.LinearList;
public class LinkedList1 {
    protected Object elem;
    protected LinkedList1 next;
    protected LinkedList1 prior;
    public LinkedList1(Object elem)
    {
        this.elem=elem;
    }
    public LinkedList1(){}
}

package DataStructure.LinearList;
public class CircularDoubleLinkedList {
    private LinkedList1 list;
    private LinkedList1 head;
    public void InitList()
    {
        list=new LinkedList1();
        this.head=list;
        head.next=list;
        head.prior=list;
        head.elem=null;
    }
    public Boolean DestoryList()
    {
        try
        {
            ClearList();
            head=null;
            return true;
        }
        catch (NullPointerException e)
        {
            System.out.println("This DoubleLinkedList has been destoried");
            return true;
        }
    }
    public Boolean ClearList()
    {
        LinkedList1 temp=head;
        while (temp.next!=head)
        {
            temp.elem=null;
            temp.prior=null;
            temp=temp.next;
        }
        temp.next=null;
        head.next=head;
        head.prior=head;
        return true;
    }
    public Boolean ListEmpty()
    {
        if (head.next!=head)
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    public int ListLength()
    {
        LinkedList1 temp=head;
        int i=0;
        while (temp.next!=head)//&&head.prior!=temp
        {
            i++;
            temp=temp.next;
        }
        return i;
    }
    public Object GetElem(int index)
    {
        if(index<0||index>=this.ListLength())
        {
            return -1;
        }
        else
        {
            LinkedList1 temp=head;
            int i=0;
            while (i<index)
            {
                i++;
                temp=temp.next;
            }
            return temp.elem;
        }
    }
    public int LocateElem(Object elem)
    {
        LinkedList1 temp=head;
        for(int i=0;i<this.ListLength();i++)
        {
            if (temp.elem.equals(elem))
            {
                return i;
            }
            else
            {
                temp=temp.next;
            }
        }
        return -1;
    }
    public Object PriorElem(Object elem)
    {
        LinkedList1 temp=head;
        for(int i=0;i<this.ListLength()-1;i++)
        {
            if(temp.next.elem.equals(elem))
            {
                return temp.elem;
            }
            else if (this.LocateElem(elem)==0)
            {
                return head.prior.prior.elem;
            }
            else
            {
                temp=temp.next;
            }
        }
        return -1;
    }
    public Object NextElem(Object elem)
    {
        LinkedList1 temp=head;
        for (int i = 0; i < this.ListLength(); i++)
        {
            if(temp.elem.equals(elem))
            {
                if (this.LocateElem(elem)==this.ListLength()-1)
                {
                    return temp.next.next.elem;
                }
                else
                {
                    return temp.next.elem;
                }
            }
            else
            {
                temp=temp.next;
            }
        }
        return -1;
    }
    public Boolean ListInsert(Object elem,int index)
    {
        if(index<0||index>this.ListLength())
        {
            return false;
        }
        LinkedList1 temp=head;
        LinkedList1 node=new LinkedList1(elem);
        if(index==0)
        {
            addFirst(elem);
        }
        if(index>0)
        {
            int i=1;
            while(i<index)
            {
                temp=temp.next;
                i++;
            }
            node.next=temp.next;
            temp.next.prior=node;
            temp.next=node;
            node.prior=temp;
        }
        return true;
    }
    public void addFirst(Object elem)
    {
        LinkedList1 node=new LinkedList1(elem);
        LinkedList1 temp=head;
        while (temp.next!=head)
        {
            temp=temp.next;
        }
        temp.next=node;
        node.next=head;
        node.prior=temp;
        head.prior=node;
        head=node;
    }
    public void addAfter(Object elem)
    {
        int i=0;
        LinkedList1 temp=head;
        if (this.ListLength()==0)
        {
            addFirst(elem);
        }
        else
        {
            while (i<this.ListLength()-1)
            {
                temp=temp.next;
                i++;
            }
            LinkedList1 node=new LinkedList1(elem);
            node.next=temp.next;
            temp.next.prior=node;
            temp.next=node;
            node.prior=temp;
        }
    }
    public Boolean DeleteElem(int index)
    {
        if(index<0||index>this.ListLength()-1)
        {
            return false;
        }
        if(index==0)
        {
            LinkedList1 pre=head.next;
            LinkedList1 temp=head;
            LinkedList1 node=head;
            while (node.next!=head)
            {
                node=node.next;
            }
            node.next=pre;
            pre.prior=node;
            head=pre;
            temp.next=null;
            temp.prior=null;
            return true;
        }
        else
        {
            LinkedList1 temp=head;
            for (int i = 0; i < index-1; i++) {
                temp=temp.next;
            }
            LinkedList1 delete=temp.next;
            temp.next=delete.next;
            delete.next.prior=temp;
            delete.next=null;//可有可无
            delete.prior=null;//可有可无
            return true;
        }
    }
    public void TraverseList()
    {
        LinkedList1 temp=head;
        while(temp.next!=head)
        {
            System.out.print(temp.elem+"\t");
            temp=temp.next;
        }
        System.out.println("");
    }
    public void TraverseListByReverseOrder()
    {
        int i=0;
        LinkedList1 temp=head;
        while (i<this.ListLength()-1)//
        {
            temp=temp.next;
            i++;
        }
        while (temp!=head.prior)head
        {
            System.out.print(temp.elem+"\t");
            temp=temp.prior;
        }
        System.out.println("");
    }
}

 

 

 

 

 

荧光百叶草
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
双向循环链表代码实践
NineFailure的博客
03-28 536
双向循环链表代码实践
java双向循环链表的实现代码
09-05
介绍了java双向循环链表的实现代码，有需要的朋友可以参考一下
双向循环链表代码
m0_49201977的博客
02-09 231
双向链表也叫双链表，是链表的一种，它的每个数据结中都有两个指针，分别指向直接后驱和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便的访问它的前驱结点和后驱结点。易班我们都称为双向循环链表 public class LinkedList<E> implements List<E> , Dequeue<E> , Stack<E> { @Override public void addFirst(E element) { .
双向循环链表代码编写
qq_33163046的博客
02-03 9913
链表的使用里，双向循环链表的使用是最广的。双向链表的每个数据结点中都有两个指针，分别指向直接后继和直接前驱，所以从双向链表的任意一个结点开始，都可以很方便的访问它的前驱结点和后继结点。  这是我练习的一个双向链表的代码，用VS2017环境编译，因为本人偏爱日志调试的方法，所以代码里日志打印内容占了一定的行数。  在写之前参考了一些资料，尤其是这篇博客（http://blog.csdn.net/
循环双链表代码（仅涉及简单操作）
独自莫凭欗的博客
01-10 199
循环双链表代码： #include <iostream> using namespace std; typedef struct DLNode//双循环链表结构定义 { int data; struct DLNode *prior; struct DLNode *next; }DLNode,*DLinkList; void InitList(DLinkList &L) { L=(DLNode *)malloc(sizeof(DLNode)); L->next=L;
【数据结构】双链表的演示
haonanren2bu2的专栏
02-17 817
双链表 实现增加、删除、修改功能 #include #include typedef struct Data { Data *prior; // 前驱指针 Data *next; // 后继指针 int elem; // 数据元素 }DoubleLinked,*PDoubleLinked; void DisDoubleLinked(PD
双向循环链表C代码实现
10-10
双向循环链表，队列，代码详细实现，已进行详细备注。
C++实现双向循环链表
12-20
本文实例为大家分享了C++实现双向循环链表的具体代码，供大家参考，具体内容如下 一、概念 1.在双链表中的每个结点应有两个链接指针：  lLink -> 指向前驱结点 （前驱指针或者左链指针） rLink->指向后继结点...
JavaScript数据结构之双向链表和双向循环链表的实现
10-18
本文将深入探讨这两种链表的实现原理，并通过代码示例进行详细解析。 首先，双向链表（Doubly Linked List）与普通的单向链表的主要区别在于，每个节点不仅包含指向下一个节点的指针，还包含一个指向前一个节点的...
深入解析C++的循环链表与双向链表设计的API实现
09-02
实现约瑟夫问题的代码通常包括创建循环链表，依次添加人（节点），然后用游标进行报数和删除操作，直到只剩下一个人。在这个过程中，`CircleList_Next()`函数是关键，它使得在链表中按顺序访问变得简单。 总结起来...
数据结构-双链表和双循环链表(C语言代码)
weixin_50246370的博客
08-10 359
双链表和双循环链表单链表双循环链表 单链表 单向链表特点：   1.可以轻松的到达下一个节点, 但是回到前一个节点是很难的.   2.只能从头遍历到尾或者从尾遍历到头(一般从头到尾) 双向链表特点   1.每次在插入或删除某个节点时, 需要处理四个节点的引用, 而不是两个. 实现起来要困难一些   2.相对于单向链表, 必然占用内存空间更大一些.   3.既可以从头遍历到尾, 又可以从尾遍历到头 双向链表的定义:   双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接
双向循环链表的基础代码
MORE_HELLO的博客
07-30 320
双向循环链表： 1、设计节点 2、初始化空链表 3、新建一个节点 4、插入节点 5、删除节点 6、移动节点 7、查找节点 8、遍历链表 代码： #include<stdlib.h> #include<stdbool.h> #include<stdio.h> #include<string.h> #include<stdbool.h> typedef struct node { int data; struct node *prev; struct
【数据结构】双向链表（带头双向循环链表）——超详细代码
qq_59702185的博客
08-15 1773
在上一篇文章我们已经介绍了链表的分类，链表的种类非常多，分为带头还是不带头、单向的还是多向的、单向还是双向循环……上一节我们学习了不带头单向的不循环的链表，这一节，我们主要实现带头双向循环的链表。如果我们把这两种结构的链表掌握的话，那么所有类型的链表我们都可以自己实现了带头双向链表有一个数据域和两个指针域。指针域一个是前驱指针，指向前一个节点，一个是后继指针，指向后一个节点。//前驱节点 struct ListNode * next;//后继节点 LTDataType data;//数据域 };...
【代码分享】双向循环链表的C语言实现
Nonoas的博客
07-05 171
在工作中的项目有用到双链表，尤其是跟着别人写双链表代码的思路，自己去看总觉得没那么顺，感觉以后也会经常用到，所以索性自己写一个出来，细节由自己去把握，终于是理解了这一块，以下是实现双链表的所有源码：#include<stdio.h> #include<malloc.h> typedefstructList { structLi......
有头节点的双向循环链表源代码
cat_want_fly的博客
01-14 266
#include &lt;stdio.h&gt; #include &lt;assert.h&gt; #include &lt;stdlib.h&gt; #include &lt;malloc.h&gt; //带头节点双向循环 //带头节点优点容易写删除操作 双向优点可以找到节点前一个，循环优点容易找到尾节点 typedef int LTDateType; typedef struct L...
C语言实现双向循环链表
BeiXi's Blog
01-31 2380
在之前的文章中，我写过一篇关于C语言实现双向链表博文，介绍了双向链表的实现过程以及双向链表的优势，接下来我首先给大家介绍一下循环链表和双向链表的区别，之后再给大家介绍双向循环链表的具体实现。 循环链表和双向链表的区别 1、最后一个结点指针指向不同 在建立一个循环链表时，必须使其最后一个结点的指针指向表头结点，而不是像双向链表那样置为NULL。此种情况还用于在最后一个结点后插入一个新的结点。 2、判...
双向循环链表(C语言实现)
TheWayForDream
10-28 960
双向循环链表 我们知道单链表对于最后一个元素的删除和插入是很不方便的，需要一直遍历到最后一个元素才行，而双向循环链表只需要找到，头节点的上一个元素的地址即可 双向循环链表中每一个元素块都有两个指针prev和next，prev连接它的上一个元素的地址，而next连接它下一个元素的地址，为了实现更好的删除和插入操作，一般把链表设置为带头结点的 这样我们就可以利用双向循环链表实现增删改查 双向链表结构图 1.初始化链表 typedef struct node { int key; node *prev,*n
双向循环链表的讲解及实现（图解+代码/C语言）
qq_62306969的博客
01-04 3674
本文主要分享了双向循环链表（带头）的写法，使用C语言完成，文中附有具体的结构图片帮助大家理解，希望对大家有帮助
【数据结构-C语言】双向循环链表
sakura0908的博客
03-02 1137
对链表而言，双向均可遍历是最方便的，另外首尾相连循环遍历也可打打增加链表操作的便捷性。因此，双向循环链表，是在实际运用中最常见的链表形态。
JAVA实现双向循环链表代码
最新发布
07-14
Sure! Here's an example of Java code to implement a doubly circular linked list: ```java public class DoublyCircularLinkedList { private Node head; private int size; ... private class Node { ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

荧光百叶草

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

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

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

打赏作者

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

抵扣说明：

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

余额充值