The principle doubly linked list

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 
}