python实现·数据结构与算法之双向循环链表

最新推荐文章于 2024-04-27 16:50:48 发布
最新推荐文章于 2024-04-27 16:50:48 发布
阅读量530 收藏 9
点赞数
分类专栏： Python实现 文章标签： python 数据结构 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lb971216008/article/details/107046349
版权

双向循环链表定义

双向循环链表(Double Cycle Linked List)是双向链表的一种更复杂的变形，头结点的上一节点链接域指向尾结点，而尾结点的下一节点链接域指向头节点。

节点示意图

节点示意图

  • 表元素域elem用来存放具体的数据。
  • 链接域prev用来存放上一个节点的位置（python中的标识）
  • 链接域next用来存放下一个节点的位置（python中的标识）

双向循环链表示意图

双向链表示意图

双向循环链表的基本操作

  • is_empty() 判断链表是否为空
  • length 链表长度
  • travel() 遍历整个链表，打印元素
  • add(item) 在链表头部添加元素
  • append(item) 在链表尾部添加元素
  • insert(pos, item) 在指定位置插入元素
  • remove(item) 删除元素
  • clear() 清空链表
  • is_contain(item) 判断元素是否存在

Python 代码实现

# 节点代码实现

class Node(object):
    """双向链表节点"""
    def __init__(self, item):
        self.item = item
        self.next = None
        self.prev = None

# 双向循环链表代码实现

class DoubleCycleLinkList(object):
    """双向循环链表"""
    def __init__(self):
        self._head = None

    def is_empty(self):
        """判断链表是否为空"""
        return self._head is None
    
    @property
    def length(self):
        """返回链表的长度"""
        if self.is_empty():
            return 0
        count = 1
        cur = self._head
        while cur.next != self._head:
            count += 1
            cur = cur.next
        return count
    
    def travel(self):
        """遍历链表"""
        if self.is_empty():
            return
        cur = self._head
        print(cur.item)
        while cur.next != self._head:
            cur = cur.next
            print(cur.item)
        print("")
        
    def add(self,item):
        """头部添加节点"""
        node = Node(item)
        if self.is_empty():
            # 如果是空链表，将_head指向node
            self._head = node
            # 将node的next指向_head的头节点
            node.next = self._head
            # node.prev = self._head
            self._head.prev = node
        else:
            # 尾结点为 self._head.prev
            # 尾结点next指向node
            self._head.prev.next = node
            # node的prev指向尾结点
            node.prev = self._head.prev
            # 将node的next指向头节点self._head
            node.next = self._head
            # 头结点的prev指向node
            self._head.prev = node
            # 头指针指向node
            self._head = node
    
    def append(self, item):
        """尾部添加元素"""
        node = Node(item)
        if self.is_empty():
            # 如果是空链表，将_head指向node
            self._head = node
        else:
            # 尾部节点为self._head.prev
            # 尾结点的next指向node
            self._head.prev.next = node
            # node的prev指向尾结点
            node.prev = self._head.prev
            
        # 将node的next指向头节点self._head
        node.next = self._head
        # 头指针指向node
        self._head.prev = node
    
    def is_contain(self, item):
        """查找节点是否存在"""
        if self.is_empty():
            return False
        cur = self._head
        if cur.item == item:
            return True
        while cur.next != self._head:
            cur = cur.next
            if cur.item == item:
                return True
        return False
    
    def insert(self, pos, item):
        """在指定位置添加节点"""
        if pos <= 0:
            self.add(item)
        elif pos > (self.length-1):
            self.append(item)
        else:
            node = Node(item)
            cur = self._head
            count = 0
            # 移动到指定位置的前一个位置
            while count < (pos-1):
                count += 1
                cur = cur.next
            node.next = cur.next
            cur.next.prev = node
            node.prev = cur
            cur.next = node
            
    def remove(self, item):
        """删除一个节点"""
        # 若链表为空，则直接返回
        if self.is_empty():
            return
        # 将cur指向头节点
        cur = self._head
        # 若头节点的元素就是要查找的元素item
        if cur.item == item:
            # 如果链表不止一个节点
            if cur.next != self._head:
                # 尾节点为self._head.prev
                # 尾节点的next指向self._head.next
                self._head.prev.next = self._head.next
                # self._head.next为新头节点，其prev指向尾结点
                self._head.next.prev = self._head.prev
                # 头指针指向新节点
                self._head = self._head.next
            else:
                # 链表只有一个节点
                self._head = None
        else:
            pre = self._head
            # 第一个节点不是要删除的
            while cur.next != self._head:
                # 找到了要删除的元素
                if cur.item == item:
                    # 删除
                    cur.prev.next = cur.next
                    cur.next.prev = cur.prev
                    return
                else: 
                    cur = cur.next
            # cur 指向尾节点
            if cur.item == item:
                # 尾部删除
                self._head.prev = cur.prev
                cur.prev.next =  self._head
    
    def clear(self):
        """清空链表"""
        self._head = None
                
    def __len__(self):
        """可使用len()获取链表长度"""
        return self.length
    
    def __iter__(self):
        """可使用循环遍历链表"""
        if self.is_empty():
            return
        cur = self._head
        yield cur.item
        while cur.next != self._head:
            cur = cur.next
            yield cur.item
    
    def __contains__(self, item):
        """可使用in判断元素是否在链表中"""
        return self.is_contain(item)

# 测试数据

if __name__ == '__main__':
    print("---创建链表---")
    dcl_list = DoubleCycleLinkList()
    dcl_list.add(1)
    dcl_list.add(2)
    dcl_list.append(3)
    dcl_list.insert(2, 4)
    dcl_list.insert(4, 5)
    dcl_list.insert(0, 6)
    print("length:",len(dcl_list))
    dcl_list.travel()
    print(dcl_list.is_contain(3))
    print(dcl_list.is_contain(8))
    print(3 in dcl_list)
    print(8 in dcl_list)
    print("---中间删除元素 1---")
    dcl_list.remove(1)
    print("length:",len(dcl_list))
    dcl_list.travel()
    print("---头部删除元素 6---")
    dcl_list.remove(6)
    print("length:",len(dcl_list))
    dcl_list.travel()
    print("---尾部删除元素 5---")
    dcl_list.remove(5)
    print("length:",len(dcl_list))
    dcl_list.travel()
    print("---循环遍历---")
    for i in dcl_list:
        print(i)

# 输出结果

---创建链表---
length: 6
6
2
1
4
3
5

True
False
True
False
---中间删除元素 1---
length: 5
6
2
4
3
5

---头部删除元素 6---
length: 4
2
4
3
5

---尾部删除元素 5---
length: 3
2
4
3

---循环遍历---
2
4
3

算法分析

操作复杂度
访问元素 O ( n ) O(n) O(n)
在头部插入/删除 O ( 1 ) O(1) O(1)
在尾部插入/删除 O ( 1 ) O(1) O(1)
在中间插入/删除 O ( n ) O(n) O(n)

联系我们

个人博客网站：http://www.bling2.cn/

Github地址：https://github.com/lb971216008/Use-Python-to-Achieve

知乎专栏：https://zhuanlan.zhihu.com/Use-Python-to-Achieve

小专栏：https://xiaozhuanlan.com/Use-Python-to-Achieve

博客园：https://www.cnblogs.com/Use-Python-to-Achieve

关注微信公众号【不灵兔】，获取更多资料
南风以南
关注
专栏目录
python实现双向循环链表基本结构及其基本方法
python之战
04-07 384
双向循环链表是在双向链表的基础上发展的，双向链表的最后一个节点指向起始节点，起始节点的上一个节点指向最后一个节点，就得到双向循环链表。 双向循环链表比双向链表具有更多的优势，节点的增加和删除有很多优化的地方，从起点开始不必循环完整个链表就可以增加或删除节点。 首先定义双向链表的基本类和节点的基本类： image class Node: def __init__(self, i...
python实现数据结构中双向循环链表操作的示例
12-16
双向循环链表是一种重要的数据结构，它允许我们在链表的两端进行插入和删除操作，同时每个节点都包含指向其前一个和后一个节点的引用，形成一个闭合的循环。在给定的示例中，我们看到了如何用Python实现这种数据结构...
python实现 双向循环链表
weixin_30566063的博客
08-09 145
最近身边的朋友在研究用python来实现数据结构。遇到一个问题就是双向循环链表的实现，改指向的时候总是发蒙。 我自己尝实现了一个python的双向循环链表。附上代码，希望对大家有帮助。 如果不懂什么是双向循环链表的伙伴，需要补习一下数据结构的基础之后哦~~~ 在python当中 用一个类Node 来实现链表的节点，节点数据有三个变量： 　　prev：前驱指针： 用于指向当前节点前一个节点 ...
python实现双向循环链表
GGBond的博客
04-25 372
'''每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值； 而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。''' class Node(object): def __init__(self,item): self.item=item#存放数据 self.next=None#下一个节点的地址 self.pre...
python 双向循环链表实现_Python双向循环链表实现方法分析
weixin_35676939的博客
12-30 259
本文实例讲述了Python双向循环链表实现方法。分享给大家供大家参考，具体如下：最近身边的朋友在研究用python来实现数据结构。遇到一个问题就是双向循环链表的实现，改指向的时候总是发蒙。我自己尝实现了一个python的双向循环链表。附上代码，希望对大家有帮助。如果不懂什么是双向循环链表的伙伴，需要补习一下数据结构的基础之后哦~~~在python当中 用一个类Node 来实现链表的节点，节点数据有...
Python写数据结构:双向循环链表
theLostLamb的博客
02-01 632
注：有头结点 #!/usr/bin/python3.5 # _*_coding:utf-8 class Node: def __init__(self, value): self.data = value self.next = None self.prev = None class CycleDoubleLinkList:
Python实现的数据结构与算法之链表详解
12-24
本文实例讲述了Python实现的数据结构与算法之链表。分享给大家供大家参考。具体分析如下： 一、概述 链表（linked list）是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的...
Python数据结构与算法之链表定义与用法实例详解【单链表、循环链表】
09-21
链表的实现和操作不仅限于此，还可以扩展到更复杂的数据结构，如双向循环链表、带头结点和尾结点的链表等。通过理解和掌握链表，可以更好地理解和应用各种算法，如排序算法（如归并排序、快速排序）、查找算法（如...
双向循环链表（python代码）
Andrew的博客
09-27 469
双向循环链表（python代码） # coding:utf-8 class Node(): def __init__(self,elem): self.elem = elem self.pre = None self.next = None class DCLL(): def __init__(self): self....
双向循环链表python(数据结构与算法)
qq_33465047的博客
05-06 976
1概念 2.操作 is_empty() 链表是否为空 length() 链表长度 travel() 遍历链表 add(item) 链表头部添加 append(item) 链表尾部添加 insert(pos, item) 指定位置添加 remove(item) 删除节点 search(item) 查找节点是否存在 class Node(object): # 节点...
数据结构之python实现双向循环链表
lbj1260200629的博客
11-09 605
1.双向循环链表 每个节点有两个链接： 一个指向前一个节点，当此节点为第一个节点时，指向最后一个节点； 而另一个指向下一个节点，当此节点为最后一个节点时，指向第一个节点。 2.操作 is_empty() 链表是否为空 length() 链表长度 travel() 遍历链表 add(item) 链表头部添加 append(item) 链表尾部添加 insert(pos, item) 指定位置添加 ...
python实现的循环双向链表
最新发布
weixin_40756114的博客
04-27 404
【代码】python实现的循环双向链表。
python双向链表以及双向循环链表
tt丫的博客
01-29 1789
深度学习入门小菜鸟，希望像做笔记记录自己学的东西，也希望能帮助到同样入门的人，更希望大佬们帮忙纠错啦~侵权立删。 目录 一、双向链表和双向循环链表概念 二、双向链表的实现 1、建立节点对象 2、链表对象的初始定义 3、判断链表是否为空 4、获取链表长度 5、向头部添加节点 6、向尾部添加节点 7、指定位置插入节点 8、删除指定位置的节点 9、查找是否有该数据的节点 10、遍历输出整个链表 11、输入数据创建链表 12、具体调用 三、双向循环链表的实现 1、建立节点对象 2
python 双向循环链表
sinat_38195894的博客
03-05 461
class Node(object): def __init__(self,pre=None,value=None,next=None): self.pre = pre self.value = value self. next = next class CircualDoubleLinkedlist(object): def _...
python 双向链表_数据结构-双向链表（Python实现）
weixin_39737317的博客
11-21 138
数据结构在编程世界中一直是非常重要的一环，不管是开发还是算法，哪怕是单纯为了面试，数据结构都是必修课，今天我们介绍链表中的一种——双向链表的代码实现。好了，话不多说直接上代码。双向链表首先，我们定义一个节点类：Nodeclass Node:def __init__(self, data):self.data = dataself.next = Noneself.prev = Nonedef get...
python数组-双向循环链表
qq_42811420的博客
04-24 214
python数组-双向循环链表 ##具体代码 #include<stdio.h> #include <stdlib.h> #include<malloc.h> #define MAXSIZE 100 typedef struct Node{ char date; struct Node* prior; struct Node* next; }Node; ...
【数据结构】——双向循环链表，使用Python创建一个简单的双向循环链表（详解）
她的坏机器人
02-13 583
双向循环链表 每个结点有两个指针域，分别指向前驱结点和后继结点，尾结点的后继指针指向头结点，头结点的前驱指针指向尾结点。整体形成一个双向连通的环。 创建一个结点类： class Node(object): """结点类""" def __init__(self, data): self.data = data self.pre = ...
python 线性表——双向循环链表
qq_60884870的博客
04-22 368
# 实现双向循环链表 # 头指向尾， 尾指向头 # 特点是不用特意用循环去找到尾结点 用 self.__head.pre 可以表示尾结点 class Node(object): def __init__(self, item): self.elem = item self.prev = None self.next = None class DounleCycleLinklist(object): def __init__(self, .
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

南风以南

如给您带来些许明朗，赏一杯香茗

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

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

打赏作者

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

抵扣说明：

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

余额充值