Python 实现双向链表(图解)

原创 2015年11月20日 16:15:48

Python 实现双向链表(图解)


双向链表

双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点。

双向链表基本方法实现(Python)

1. 初始化链表

定义节点结构:指针域pre、next和数据域data
为方便操作添加了head和tail节点,初始化时head.next–>tail,tail.pre–>next

"""节点类"""
class Node(object):
    def __init__(self, data=None):
        self.data = data
        self.pre = None
        self.next = None

"""初始化双向链表"""

def __init__(self):
    """
    设置头尾,操作比较容易
    头--(next)--》尾
    尾--(pre)--》头
    :return:
    """
    head = Node()
    tail = Node()
    self.head = head
    self.tail = tail
    self.head.next = self.tail
    self.tail.pre = self.head

初始化

2. 获取链表长度

起始head,每有一个节点,length+1

"""获取链表长度"""

def __len__(self):
    length = 0
    node = self.head
    while node.next != self.tail:
        length += 1
        node = node.next
    return length

3. 追加节点

因为有tail 节点,所以找到tail.pre 节点就好了

"""追加节点"""

def append(self, data):
    """
    :param data:
    :return:
    """
    node = Node(data)
    pre = self.tail.pre
    pre.next = node
    node.pre = pre
    self.tail.pre = node
    node.next = self.tail
    return node

追加节点

4. 获取节点

获取节点要判断index正负值

 """获取节点"""
def get(self, index):
    """
    获取第index个值,若index>0正向获取else 反向获取
    :param index:
    :return:
    """
    length = len(self)
    index = index if index >= 0 else length + index
    if index >= length or index < 0: return None
    node = self.head.next
    while index:
        node = node.next
        index -= 1
    return node

5. 设置节点

找到当前节点赋值即可

"""设置节点"""

def set(self, index, data):
    node = self.get(index)
    if node:
        node.data = data
    return node

6. 插入节点

插入节点需要找到插入节点的前一个节点pre_node和后一个节点next_node(索引index的正负,前一节点不同,需要判断一下),然后将pre_node.next–>node,node.pre->pre_node;next_node.pre–>node,node.next–>next_node

"""插入节点"""

def insert(self, index, data):
    """
    因为加了头尾节点所以获取节点node就一定存在node.next 和 node.pre
    :param index:
    :param data:
    :return:
    """
    length = len(self)
    if abs(index + 1) > length:
        return False
    index = index if index >= 0 else index + 1 + length

    next_node = self.get(index)
    if next_node:
        node = Node(data)
        pre_node = next_node.pre
        pre_node.next = node
        node.pre = pre_node
        node.next = next_node
        next_node.pre = node
        return node

插入节点

7. 删除节点

删除节点,也要区分一下索引的正负。找到当前节点的前一个节点pre_node和后一个节点next_node,将pre_node.nex–>next_node即可

"""删除节点"""

def delete(self, index):
    node = self.get(index)
    if node:
        node.pre.next = node.next
        node.next.pre = node.pre
        return True

    return False

删除节点

8. 反转链表

反转链表的实现有多种方式,比较简单的就是生成一个新的链表--》可以用数组存储所有节点让后倒序生成新的链表
在这里用下面这种方式生产:
可能有点绕
1.node.next –> node.pre;node.pre –> node.next(递归)
2.head.next –> None;tail.pre –> None
3.head–>tail;tail–>head

"""反转链表"""
def __reversed__(self):
    """
    1.node.next --> node.pre
      node.pre --> node.next
    2.head.next --> None
      tail.pre --> None
    3.head-->tail
     tail-->head
    :return:
    """
    pre_head = self.head
    tail = self.tail

    def reverse(pre_node, node):
        if node:
            next_node = node.next
            node.next = pre_node
            pre_node.pre = node
            if pre_node is self.head:
                pre_node.next = None
            if node is self.tail:
                node.pre = None
            return reverse(node, next_node)
        else:
            self.head = tail
            self.tail = pre_head

    return reverse(self.head, self.head.next)

反转链表

9. 清空链表

类似初始化

"""清空链表"""
def clear(self):
    self.head.next = self.tail
    self.tail.pre = self.head

清空链表

git 路径 https://github.com/wangpanjun/datastructure.git


作者 [@小王]
2015 年 11月

[从头学数学] 第262节 Python实现数据结构:双向链表

剧情提要: 阿伟看到了一本比较有趣的书,是关于《计算几何》的,2008年由北清派出版。很好奇 它里面讲了些什么,就来看看啦。 正剧开始: 星历2016年09月17日 12:07:43,...
  • mwsister
  • mwsister
  • 2016年09月17日 12:06
  • 741

Python 实现双链表,栈,队列

1.双链表 class Node(object): def __init__(self, value=None): self._prev = None self...
  • python_tty
  • python_tty
  • 2017年02月24日 17:07
  • 633

Python 实现单向链表

Python 实现单向链表 什么是 链表 链表顾名思义就是~链 链表是一种动态数据结构,他的特点是用一组任意的存储单元存放数据元素。链表中每一个元素成为“结点”,每一个结点都是由数据域和...
  • qq490691606
  • qq490691606
  • 2015年11月20日 13:50
  • 4359

Python链表的实现

单链表的实现 python实现链表依赖于类生成的实例,每个节点都是一个对象,组合在一起形成一个完整链表对于node类只需关注两点:data 和 pnext 对于linked_list需要关心的:h...
  • lvhuiyang
  • lvhuiyang
  • 2016年12月11日 11:30
  • 3414

Python 数据结构与算法——列表(链表,linked list)

Python 中的 list 并不是我们传统(计算机科学)意义上的列表,这也是其 append 操作会比 insert 操作效率高的原因。传统列表——通常也叫作链表(linked list)——通常是...
  • lanchunhui
  • lanchunhui
  • 2016年03月21日 08:00
  • 8134

python的链表定义以及实现

链表(linked list)是一组数据项的集合,其中每个数据项都是一个节点的一部分,每个节点还包含指向下一个节点的链接. 链表的数据结构如下图所示 在链表中删除操作可以通过修改指针来...
  • DinnerHowe
  • DinnerHowe
  • 2017年02月27日 18:57
  • 1455

一个python实现的有魔法方法(magic method)的单链表(静态链表)

实现了一个静态单链表。 加入了一些魔法函数,使得它可以像list那样使用索引功能切片功能和for循环。...
  • psmlbj
  • psmlbj
  • 2017年03月10日 12:45
  • 303

Python 实现一个全面的单链表

前言 实现清单 链表实现 总结前言算法和数据结构是一个亘古不变的话题,作为一个程序员,掌握常用的数据结构实现是非常非常的有必要的。实现清单实现链表,本质上和语言是无关的。但是灵活度却和实现它的语言密切...
  • Marksinoberg
  • Marksinoberg
  • 2017年04月05日 19:28
  • 7946

单链表-Python操作

链表是数据结构中最基本常用的,C++语言中单链表是利用指针操作实现的,python作为面向对象编程的,可以使用创建一个Node类来实现链表,利用类的属性引用来代替指针操作。 下面我们创建了一个...
  • qq_14959801
  • qq_14959801
  • 2016年11月04日 10:31
  • 3522

用python实现链表操作

用python实现初始化链表、链表长度、插入、删除、新增、查找、逆序
  • w2211384272
  • w2211384272
  • 2015年07月30日 16:58
  • 3604
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Python 实现双向链表(图解)
举报原因:
原因补充:

(最多只允许输入30个字)