# brief introduction

From: Easy to understand and explain linked list

One way linked list:

Bidirectional 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.

Bidirectional 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.head = None 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.

- Judge whether the linked list is empty:

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

- Add a node at the end of the linked list:

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

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.

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

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 dfs(head) return head