main Package Import "FMT" type struct {LinkNode the Data interface data {} // Prev * a pointer on LinkNode // Next * LinkNode // next pointer } // create a doubly linked list (data set) FUNC (Node * LinkNode) the Create (the Data interface {...}) { IF node nil == { return } IF len (the Data) == 0 { return } // recording head node head: = node for _, V: the Data Range = { // Create the new node the newNode: = new new (LinkNode) newNode.Data = V // points to a node on the new node newNode.Prev = node // next current node is a new node node.Next the newNode = // current node to the next node node = node.Next } // Prev head node a node may point to the last node //head.Prev=node Node = head } // print doubly linked list FUNC (Node * LinkNode) the Print () { IF Node nil == { return } // positive sequence of print data for Node! = nil { IF node.Data! = nil { fmt.Println (node.Data) } Node = node.Next } } // print doubly linked list reverse func (node * LinkNode) Print02 ( ) { Node nil == {IF return } // end point list for node.Next! = nil { Node = node.Next } // forward from the print data for node.Prev! = nil { IF node.Data! = nil { Node = node.Prev fmt.Println (node.Data) } IF node == {nil } } // Returns the length of the data value of the number FUNC (Node * LinkNode) the Length () {int IF Node nil == { return -1 } I: = 0 for nil node.Next = {! I ++ Node = node.Next } I return } // insert data (index data) FUNC (Node * LinkNode) index (int index, the data interface {}) { IF Node nil == { return } IF index <0 { return } IF the data == {nil return } // recording a node preNode: node = // find the insertion cycle node for I: = 0; I <index; I ++ { preNode = node return } Node = node.Next } // create a new node the newNode: = new new (LinkNode) newNode.Data the Data = // pointer field point to the new node and the node a next node newNode.Next = Node newNode.Prev = preNode next node on // the new node is a node preNode.Next = newNode one node to the next node of a // new node node.Prev the newNode = } // delete data (subscript) FUNC (node * LinkNode) the Delete (int index) { IF node nil == { return } IF index <0 { return } // recording a node preNode: = node for I: = 0; I <index; I ++ { preNode node = IF node == {nil return } Node = node.Next } // delete nodes // Next to the next node becomes a node of the current node preNode.Next = node.Next // upper node a next node of the current node becomes a node on the // current node a node on the next node is a node node.Next.Prev = preNode // current node destruction node.Data = nil node.Next = nil node.Prev = nil node = nil } // list destruction func (node LinkNode *) the Destroy () { IF Node nil == { return } node.Next.Destroy () node.Data = nil node.Next = nil node.Prev = nil Node = nil }