python/golang 删除链表中的元素

先用使用常规方法，两个指针:

golang实现：

type Node struct {
 value int
 next *Node
}

type Link struct {
 head *Node
 tail *Node
 lenth int
}

// 向链表中添加元素
func (link *Link) add(v int) {
 if link.lenth == 0 { // 当前链表是空链表
   link.head = &Node{v, nil}
   link.tail = link.head
   link.lenth = 1
 } else {
   newNond := &Node{v, nil}
   link.tail.next = newNond
   link.tail = newNond
   link.lenth += 1
 }
}

// 删除链表中的元素(双指针)
func (link *Link) remove(v int) {
 if link.lenth == 0 {
   fmt.Println("空链表，不支持该操作")
   return
 }
 var previous *Node = nil
 for current := link.head; current != nil; current = current.next {
   if current.value == v {
     if current == link.head { // 要删除的是头节点
       link.head = current.next
     } else if current == link.tail { // 要删除的是尾节点
       previous.next = nil
       link.tail = previous
     } else { // 要删除的是中间的节点
       previous.next = current.next
     }
     link.lenth -= 1
     break
   }
   previous = current
 }
}

// 打印链表
func (link *Link) printList() {
 if link.lenth == 0 {
   fmt.Println("空链表")
   return
 }
 for cur := link.head; cur != nil; cur = cur.next {
   fmt.Printf("％d ", cur.value)
 }
 fmt.Println()
}

python实现:

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

def __str__(self):
   return str(self.value)

class Link:
 def __init__(self):
   self.head = None
   self.tail = None
   self.lenth = 0

# 向链表中添加元素
 def add(self, v):
   if self.lenth == 0: # 当前链表是空链表
     self.head = Node(v, None)
     self.tail = self.head
     self.lenth = 1
   else:
     new_node = Node(v, None)
     self.tail.next = new_node
     self.tail = new_node
     self.lenth += 1

# 打印链表
 def print(self):
   if self.lenth == 0:
     print('空链表')
     return
   cur = self.head
   while True:
     if cur == None:
       print()
       break
     print(cur, end=' ')
     cur = cur.next

# 删除链表中的元素
 def remove(self, v):
   if self.lenth == 0:
     return
   cur = self.head
   pre = None
   while True:
     if cur.value == v:
       if cur == self.head: # 要删除的是头节点
         self.head = cur.next
       elif cur == self.tail: # 要删除的是尾节点
         pre.next = None
         self.tail = pre
       else: # 要删除的是中间的节点
         pre.next = cur.next
       self.lenth -= 1
       break
     pre = cur
     cur = cur.next
     if cur == None:
       print("未找到", v)
       break

只使用使用一个指针实现链表的删除：

golang实现：

func (link *Link) remove_with_one_pointer(v int) {
 if link.lenth == 0 {
   return
 }
 if link.tail.value == v { // 要删除的节点是尾节点，需特殊处理
   if link.lenth == 1 { // 如果链表只有一个节点
     link.head = nil
     link.tail = nil
   } else { //大于一个节点
     cur := link.head
     for ; cur.next.next != nil; cur = cur.next {
     } //找到尾节点的前一个节点
     cur.next = nil
     link.tail = cur
   }
   link.lenth -= 1
   return
 }
 //要删除的节点在头部/中间 的常规情况
 for cur := link.head; cur != nil; cur = cur.next {
   if cur.value == v {
     cur.value = cur.next.value
     cur.next = cur.next.next
     link.lenth -= 1
     return
   }
 }
 fmt.Println("未找到", v)
}

python实现：

def remove_with_one_pointer(self, v):
 if self.lenth == 0:
   return
 if self.tail.value == v: # 要删除的节点是尾节点，需特殊处理
   if self.lenth == 1: # 如果链表只有一个节点
     self.head = None
     self.tail = None
   else: # 大于一个节点
     cur = self.head
     while True:
       if cur.next.next is None: # 找到尾节点的前一个节点
         break
       else:
         cur = cur.next
     cur.next = None
     self.tail = cur
   self.lenth -= 1
   return
 # 要删除的节点在头部/中间 的常规情况
 cur = self.head
 while True:
   if cur.value == v:
     cur.value = cur.next.value
     cur.next = cur.next.next
     self.lenth -= 1
     break
   cur = cur.next
   if cur is None:
     print('未找到', v)
     break

来源：https://www.jianshu.com/p/8554d637702a