# brief introduction

From: Easy to understand and explain linked list  Look at the picture and understand...

# Bidirectional linked list data structure

From:
Data structure - bidirectional linked list (Python Implementation)
Data structure has always been a very important part in the programming world. Whether it is development or algorithm, even for interview, data structure is a required course. Today, we introduce a kind of linked list - the code implementation of two-way linked list.

```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
```

OK, we define the node class and implement the methods of obtaining, modifying node data and obtaining the previous / next node.
You can instantiate a node by node = Node(10).

Next, let's define the linked list class:

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

OK, we define a linked list class and set three properties. Head represents the head node, tail represents the tail node, and length represents the length of the linked list. Next, we add some methods to the linked list class.

1. Judge whether the linked list is empty:
```def isEmpty(self):
```
```def append(self, item):
if self.length == 0:
node = Node(item)
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
```

When adding nodes, we should first judge whether the linked list is empty. In addition, we should set the next attribute for the original tail node, set the prev attribute for the new tail node, and update the tail and length attributes of the linked list.

1. Insert node in linked list:
```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)
else:
self.tail = node
self.length += 1
return True
if index == length - 1:
return self.append(item)

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
```

When inserting a node, our parameters are subscript index and data item. By default, we insert a new node after the specified subscript.

Here, we also need to consider the head node and tail node.

When inserting, first point the next and prev attributes of the new node to the corresponding node, and then point the next and prev of the front and rear nodes to the new node. At the same time, pay attention to updating the length attribute of the linked list.

# Force buckle question 430: flat multi-level two-way linked list

Title:

In the multi-level bidirectional linked list, in addition to the pointer to the next node and the previous node, it also has a sub linked list pointer, which may point to a separate bidirectional linked list. These sub lists may also have one or more of their own sub items, and so on to generate multi-level data structures, as shown in the following example.
Give you the head node at the first level of the list. Please flatten the list so that all nodes appear in the single level double linked list.

Example: Output is: python program:

```"""
# 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: depth first search algorithm
class Solution:
def flatten(self, head: "Node") -> "Node":
def dfs(node: "Node") -> "Node":
cur = node
# Record the last node of the linked list
last = None

while cur:
nxt = cur.next
# If there are child nodes, the child nodes are processed first
if cur.child:
child_last = dfs(cur.child)

nxt = cur.next
# Connect node to child:
#   Note that you only need to connect 8-11 (the connection of 11-12 has been completed in dfs(cur.child))
#   Therefore, there is no need to connect again outside the loop
cur.next = cur.child
cur.child.prev = cur

# If nxt is not empty, connect last with nxt
#   The meaning of this paragraph is to connect the last bit of the sub linked list with the next node of the current node
if nxt:
child_last.next = nxt
nxt.prev = child_last

# Set child to null
cur.child = None
last = child_last
else:
last = cur
cur = nxt

# The focus of this return value is to return child when looping the dfs process_ Last value;
# If there is no sub linked list, the return value will not work
return last