数据结构 | 双向链表学习总结

单向链表学习总结：python | 单向链表

简介

摘自：通俗易懂讲解 链表
单向链表：

双向链表：

看图理解吧。。。

双向链表数据结构

摘自：
数据结构-双向链表（Python实现）
数据结构在编程世界中一直是非常重要的一环，不管是开发还是算法，哪怕是单纯为了面试，数据结构都是必修课，今天我们介绍链表中的一种——双向链表的代码实现。

双向链表：

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.prev = None
    def getData(self):
        return self.data

    def setData(self, data):
        self.data = data

    def getNext(self):
        return self.next

    def getPrev(self):
        return self.prev

好，我们定义了节点类，并实现了获取、修改节点数据、获取上一个/下一个节点的方法。
通过node = Node(10)就可以实例化一个节点啦。

接下来我们来定义链表类：

class TwoWayList:
    def __init__(self):
        self.head = None
        self.tail = None
        self.length = 0

好，我们定义了一个链表类，并设置三个属性，head表示头节点，tail表示尾节点，length表示链表长度，接下来，我们给链表类添加一些方法。

1. 判断链表是否为空：

def isEmpty(self):
        return self.head == None

2. 在链表尾部添加节点：

def append(self, item):
        if self.length == 0:
            node = Node(item)
            self.head = node
            self.tail = node
            self.length = 1
            return
        node = Node(item)
        tail = self.tail
        tail.next = node
        node.prev = tail
        self.tail = node
        self.length += 1

添加节点的时候，我们首先要判断链表是否为空，另外要注意给原本的尾节点设置next属性，新的尾节点设置prev属性，更新链表的tail和length属性。

3. 链表中插入节点：

def insert(self, index, item):
        length = self.length
        if (index<0 and abs(index)>length) or (index>0 and index>=length):
            return False
        if index < 0:
            index = index + length
        if index == 0:
            node = Node(item)
            if self.head != None:
                self.head.prev = node
            else:
                self.tail = node
            node.next = self.head
            self.head = node
            self.length += 1
            return True
        if index == length - 1:
            return self.append(item)


        node1 = self.head
        for i in range(0, index):
            node1 = node1.next
        node2 = node1.next

        node = Node(item)
        node.prex = node1
        node.next = node2
        node1.next = node
        node2.prev = node

        self.length += 1
        return True

插入节点时候，我们参数为下标index和数据item，我们默认在指定下标的后面插入新节点。

在这里我们同样要特殊考虑头节点和尾结点的情况。

在执行插入时先将新节点的next、prev属性指向相应节点，在将前后节点的next和prev指向新节点，同时注意更新链表的length属性。

力扣第430题：扁平化多级双向链表

题目：

多级双向链表中，除了指向下一个节点和前一个节点指针之外，它还有一个子链表指针，可能指向单独的双向链表。这些子列表也可能会有一个或多个自己的子项，依此类推，生成多级数据结构，如下面的示例所示。
给你位于列表第一级的头节点，请你扁平化列表，使所有结点出现在单级双链表中。

示例：

输出为：

python程序：

"""
# Definition for a Node.
class Node:
    def __init__(self, val, prev, next, child):
        self.val = val
        self.prev = prev
        self.next = next
        self.child = child
"""
# DFS：深度优先搜索算法
class Solution:
    def flatten(self, head: "Node") -> "Node":
        def dfs(node: "Node") -> "Node":
            cur = node
            # 记录链表的最后一个节点
            last = None

            while cur:
                nxt = cur.next
                # 如果有子节点，那么首先处理子节点
                if cur.child:
                    child_last = dfs(cur.child)
                    
                    nxt = cur.next
                    # 将 node 与 child 相连：
                    #   注意这里只需要连接8-11（11-12的连接，在dfs(cur.child)中已经完成）
                    #   因此在循环外不需要再次连接
                    cur.next = cur.child
                    cur.child.prev = cur

                    # 如果 nxt 不为空，就将 last 与 nxt 相连
                    #   这段话的意思是，将子链表的最后一位，与当前节点的下一个节点双向连接
                    if nxt:
                        child_last.next = nxt
                        nxt.prev = child_last

                    # 将 child 置为空
                    cur.child = None
                    last = child_last
                else:
                    last = cur
                cur = nxt

            # 这个返回值的重点在于循环dfs过程的时候，返回child_last值；
            # 如果没有子链表，这个返回值是不起作用的
            return last

        dfs(head)
        return head