单链表python和go的代码

go version

package main
import "fmt"
type Objecter interface {} //任意对象类型
type Node struct{
    Data Objecter
    Next *Node //指针类型
}

type List struct {
    headNode *Node
}

//判断是否为空的单链表
func (l *List) IsEmpty() bool {
   if l.headNode == nil{
    return true
   }else{
    return false
   }
}

//单链表的长度
func (l *List) Length() int{
    cursor :=l.headNode
    count := 0
    for cursor != nil{
        count++
        cursor = cursor.Next
    }
    return count
}

//获取头部节点
func (l *List) GetHeadNode() *Node{
    
   return l.headNode

}

//从头部添加元素
func (l *List) Add (data Objecter){
    node:=&Node{Data:data} //传入值转为node对象
    node.Next = l.headNode //将节点的next指针指向head即可。
    l.headNode = node //再把当前的节点指向head，也就是head前移了

}

//从尾部添加元素
func (l *List) Append (data Objecter){
    //首先根据传入的值转成node节点
    node := &Node{Data:data}
    //判断是否为空
    if l.IsEmpty(){
        //将head指向当前的节点
        l.headNode = node
    }else{
        cursor:=l.headNode
        for cursor.Next!=nil{
            //游标往后元素移动
            //知道下个
            cursor = cursor.Next
        }
        cursor.Next = node
    }
}

//在指定位置添加元素
func (l *List) Insert(index int,data Objecter){
    if index <0 {
        //如果index小于0，加在头上
        l.Add(data)
    }else if index > l.Length(){
        l.Append(data)
    }else{
        pre :=l.headNode
        count:=0
        for count<(index-1){
            pre = pre.Next
            count++
        }
        node :=&Node{Data:data}
        //pre.Next表示需要插入位置的下一个节点
        //node.Next指向后面的节点
        //然后前面的节点指向node
        node.Next = pre.Next
        pre.Next = node

    }

}
func (l *List) Remove(data Objecter){
    pre := l.headNode
    if pre.Data ==data{
        l.headNode = pre.Next
    }else{
        for pre.Next != nil{
            if pre.Next.Data ==data{
                pre.Next = pre.Next.Next
            }else{
                pre = pre.Next
            }
        }
    }
}
func (l *List) Contain(data Objecter) bool {
    cursor:=l.headNode
    for cursor!=nil{
        if cursor.Data ==data{
            return true
        }
        cursor = cursor.Next
    }
    return false
}

func traverseLinkList(l *List){
    head:=l.GetHeadNode()
    for head!=nil{
        fmt.Println(head.Data)
        head = head.Next
    }
    fmt.Println("======")
}
func main() {
    list := List{}
    
    //尾部添加
    list.Append(1)
    list.Append(2)
    list.Append(3)
    list.Append(4)
     
    //头部添加
    list.Add(5)
    fmt.Println("长度===",list.Length()) 

    //判断是否为空链表
    bool:=list.IsEmpty()
    fmt.Println(bool)   

    //在指定位置2插入23
    list.Insert(2,23)
    traverseLinkList(&list)
    
    //是否包含元素23
    isContain :=list.Contain(23)
    fmt.Println("isContain: ",isContain) 

    //是否包含元素57
    isContain =list.Contain(57)
    fmt.Println("isNotContain: ",isContain)

    //删除57
    list.Remove(23)
    traverseLinkList(&list)

}

python version

class Node:
    def __init__(self,value=None):
        self.value = value
        self.next = None

class LinkList:
    def __init__(self,head = None):
        self.head = head

    def is_empty(self):
       """
       判断链表是否为空
       """
       flag = False
       pre = self.head
       if pre.value is None:
            flag = True
       return flag

    def length(self):
        """
        获取链表的长度
        """
        cursor = self.head
        count = 0
        while cursor is not None:
               cursor = cursor.next
               count+=1
        return count  

    def get_head_node(self):
        """
        获取头部节点
        """
        return self.head

    def add(self,value):
        """
        从头部添加元素
        """  
        node = Node(value =value)
        node.next = self.head
        self.head = node

    def append(self,value) :
        """
        从尾部添加元素
        """   
        node = Node(value = value)  
        cursor = self.head 
        if self.head is None:
            self.head = node
        else:    
            while cursor.next is not None:
                cursor = cursor.next
            cursor.next = node    
    def insert(self,index,value):
        if index < 0:
             self.add(value)
        elif index > self.length():
            self.append(value) 
        else:
            count = 0
            cursor = self.head
            while count < index -1:
                cursor = cursor.next
                count+=1
            node = Node(value = value)  
            # cursor.next = node.next
            # node = cursor.next
            node.next = cursor.next
            cursor.next = node
    def remove(self,value):
        cursor = self.head
        if cursor.value == value:
            self.head = cursor.next
        else:
                #判断next的值比较好
                while cursor.next is not None:
                   if cursor.next.value==value:
                        cursor.next = cursor.next.next
                   else:    
                        cursor = cursor.next
                #如果使用cursor则需要知道前面的节点是什么。
                # pre = None
                # while cursor is not None:

                #    curosr = cursor.next
                #    pre = cursor
                #    if cursor.value==value:
                #         pre.next = cursor.next

    def contains(self,value):
        cursor = self.head
        flag = False
        if cursor.value == value:
            flag = True
        else:     
            while cursor is not None:
                if cursor.value == value:
                    flag = True
                    break
                else:
                    cursor = cursor.next    
            else:
                flag = False    
        return flag
    
    def traverse_list(self):
        head = self.get_head_node()
        cursor = head
        while cursor is not None:
            print(cursor.value)
            cursor = cursor.next
        print("traverse_over")    

    
def main():
    l = LinkList()
    l.append(1)
    l.append(2)
    l.append(3)
    l.append(4)

    l.add(5)

    print("长度===",l.length()) 

    #判断是否为空链表
    bool=l.is_empty()
    print(bool)   

    #在指定位置2插入23
    l.insert(2,23)
    l.traverse_list()
    
    #是否包含元素23
    is_contain =l.contains(23)
    print("is_contain: ",is_contain) 

    #是否包含元素57
    is_contain =l.contains(57)
    print("is_not_contain: ",is_contain)

    #删除23
    l.remove(23)
    l.traverse_list()


if __name__ == "__main__":
    main()