go--双链表的实现（增删改查）改进版

之前就写过双链表的实现，但是今天看的时候发现了一个问题，就是在查询元素的时候并没有好好利用双链表的特性，所以今天又重新编辑了一下，大家看看区别

代码：

package main

import "fmt"

type Node struct {
	data int
	pre *Node
	Next *Node
}
type DoubleList struct {
	Head *Node
	length int
	Tail *Node
}
func (list *DoubleList) Create(){
	list.Head=nil
	list.Tail=nil
	list.length=0
}
func (list *DoubleList) Add(n int){
	cur:=&Node{
		data:n,
	}
	if list.length==0{
		list.Head=cur
		list.Head.pre=nil
		list.Head.Next=list.Tail
	}else if list.length==1{
		list.Tail=cur
		list.Head.Next=list.Tail
		list.Tail.pre=list.Head
		list.Tail.Next=nil
	}else{
		list.Tail.Next=cur
		cur.pre=list.Tail
		list.Tail=cur
	}
	list.length++
}
func (list *DoubleList) Get(n int)  *Node{
	if list.length==0 || n>list.length{
		return nil
	}
	node:=list.Head
	if n<=list.length/2{

		for i:=0;i<n-1;i++{
			node=node.Next
		}
	}else{
		node=list.Tail
		for j:=list.length-1;j>=n;j--{
            node=node.pre
		}
	}
    return node
}
func (list *DoubleList) Insert(i ,x int){
	node:=&Node{
		data:x,
	}
	if i==1{
		list.Head.pre=node
		node.Next=list.Head
		list.Head=node
		list.Head.pre=nil
	}else if i==list.length{
		list.Tail.Next=node
		node.pre=list.Tail
		list.Tail=node
		list.Tail.Next=nil
	}else{
        cur:=list.Get(i)
        node.pre=cur.pre
        node.Next=cur
        cur.pre=node
        node.pre.Next=node
	}
	list.length++
}
func (list *DoubleList) Delete(i int){
	if i==1{
		node:=list.Head.Next
		list.Head=node
		list.Head.pre=nil
	}else if i==list.length{
		node:=list.Tail.pre
		list.Tail=node
		list.Tail.Next=nil
	}else{
		node:=list.Get(i)
		left:=node.pre
		right:=node.Next
		left.Next=right
		right.pre=left
	}
	list.length--
}
func (list *DoubleList) Change(i,n int){
	node:=list.Get(i)
	node.data=n
}
func main() {
	list := new(DoubleList)
	list.Create()
	list.Add(1)
	list.Add(2)
	list.Add(3)
	list.Add(4)
	list.Add(5)
	list.Insert(2, 0)
	list.Delete(2)
	list.Change(2,0)
	node:=list.Get(2)
	fmt.Println(node.data)
}

主要的差别就是在查询元素的时候，先根据链表的长度确定是在后半段还是前半段，从而减少一些遍历次数