探索链表的魅力：数据结构之单向链表算法题巡礼

2023-09-15 04:24:52




**探索链表的魅力：数据结构之单向链表算法题巡礼** 

**一、单向链表初探** 

单向链表是一种重要的数据结构，它由一系列节点组成，每个节点包含一个数据项和一个指向下一个节点的指针。单向链表具有插入和删除元素的快速性能，因此在许多应用中都得到了广泛的使用。

**二、单向链表的插入算法** 

1. 在链表的头部插入元素：
```python
def insert_at_head(self, data):
    new_node = Node(data)
    new_node.next = self.head
    self.head = new_node

在链表的中间插入元素：

def insert_at_middle(self, data, after_node):
    new_node = Node(data)
    new_node.next = after_node.next
    after_node.next = new_node

在链表的尾部插入元素：

def insert_at_tail(self, data):
    new_node = Node(data)
    if self.head is None:
        self.head = new_node
    else:
        current_node = self.head
        while current_node.next is not None:
            current_node = current_node.next
        current_node.next = new_node

三、单向链表的删除算法

删除链表的头部元素：

def delete_at_head(self):
    if self.head is not None:
        self.head = self.head.next

删除链表的中间元素：

def delete_at_middle(self, node):
    if node is not None and node.next is not None:
        node.next = node.next.next

删除链表的尾部元素：

def delete_at_tail(self):
    if self.head is not None:
        current_node = self.head
        while current_node.next.next is not None:
            current_node = current_node.next
        current_node.next = None

四、单向链表的算法题巡礼

反转单向链表：

def reverse_list(self):
    prev = None
    current = self.head
    while current is not None:
        next_node = current.next
        current.next = prev
        prev = current
        current = next_node
    self.head = prev

检测单向链表是否有环：

def has_cycle(self):
    slow_ptr = self.head
    fast_ptr = self.head
    while slow_ptr and fast_ptr and fast_ptr.next:
        slow_ptr = slow_ptr.next
        fast_ptr = fast_ptr.next.next
        if slow_ptr == fast_ptr:
            return True
    return False

求单向链表的中间节点：

def get_middle_node(self):
    slow_ptr = self.head
    fast_ptr = self.head
    while fast_ptr and fast_ptr.next:
        slow_ptr = slow_ptr.next
        fast_ptr = fast_ptr.next.next
    return slow_ptr