单链表中的交替奇数和偶数节点

单链表是一种常见的数据结构，由许多节点组成。每个节点包括两部分：节点数据和一个指针，指向下一个节点。在实际应用中，我们可能需要对链表中的数据进行处理，其中有一种需求是将单链表中的奇数节点与偶数节点分别提取出来，然后将它们交替放置在一个新的链表中。

算法描述

本算法主要分为两个步骤：

1. 按照奇偶性将原链表分成两个链表
2. 将这两个链表按照奇偶交替放置在一起

分成两个链表

定义两个指针odd和even，初始指向原链表的头节点。然后，分别遍历奇数位置和偶数位置的节点，并将它们插入到分别以odd和even为头节点的两个链表中。

def segregate_nodes(head):
    odd = Node(None)
    even = Node(None)
    odd_ptr = odd
    even_ptr = even
    
    current = head
    is_odd = True
    while current:
        if is_odd:
            odd_ptr.next = current
            odd_ptr = odd_ptr.next
        else:
            even_ptr.next = current
            even_ptr = even_ptr.next
        
        is_odd = not is_odd
        current = current.next
    
    odd_ptr.next = None
    even_ptr.next = None
    
    return odd.next, even.next

交替放置

定义一个指针new_head，初始指向odd链表的头节点。然后依次将even链表中的节点插入到新链表中，直到even链表中的节点全部插入完成。最后返回新链表的头节点即可。

def alternate_nodes(odd_head, even_head):
    new_head = odd_head
    odd_current = odd_head.next
    even_current = even_head.next
    current = new_head
    
    while even_current:
        current.next = even_current
        even_current = even_current.next
        current = current.next
        
        current.next = odd_current
        odd_current = odd_current.next
        current = current.next
    
    if odd_current:
        current.next = odd_current
    
    return new_head

参考代码

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

def segregate_nodes(head):
    odd = Node(None)
    even = Node(None)
    odd_ptr = odd
    even_ptr = even
    
    current = head
    is_odd = True
    while current:
        if is_odd:
            odd_ptr.next = current
            odd_ptr = odd_ptr.next
        else:
            even_ptr.next = current
            even_ptr = even_ptr.next
        
        is_odd = not is_odd
        current = current.next
    
    odd_ptr.next = None
    even_ptr.next = None
    
    return odd.next, even.next
    

def alternate_nodes(odd_head, even_head):
    new_head = odd_head
    odd_current = odd_head.next
    even_current = even_head.next
    current = new_head
    
    while even_current:
        current.next = even_current
        even_current = even_current.next
        current = current.next
        
        current.next = odd_current
        odd_current = odd_current.next
        current = current.next
    
    if odd_current:
        current.next = odd_current
    
    return new_head

def test():
    head = Node(1)
    node2 = Node(2)
    node3 = Node(3)
    node4 = Node(4)
    node5 = Node(5)
    head.next = node2
    node2.next = node3
    node3.next = node4
    node4.next = node5
    
    new_head = alternate_nodes(*segregate_nodes(head))
    
    result = []
    current = new_head
    while current:
        result.append(current.data)
        current = current.next
        
    assert result == [1, 3, 2, 5, 4]

test()

def test():
    head = Node(1)
    node2 = Node(2)
    node3 = Node(3)
    node4 = Node(4)
    head.next = node2
    node2.next = node3
    node3.next = node4
    
    new_head = alternate_nodes(*segregate_nodes(head))
    
    result = []
    current = new_head
    while current:
        result.append(current.data)
        current = current.next
        
    assert result == [1, 3, 2, 4]

test()

def test():
    head = Node(1)
    node2 = Node(2)
    node3 = Node(3)
    head.next = node2
    node2.next = node3
    
    new_head = alternate_nodes(*segregate_nodes(head))
    
    result = []
    current = new_head
    while current:
        result.append(current.data)
        current = current.next
        
    assert result == [1, 3, 2]

test()

def test():
    head = Node(1)
    
    new_head = alternate_nodes(*segregate_nodes(head))
    
    result = []
    current = new_head
    while current:
        result.append(current.data)
        current = current.next
        
    assert result == [1]

test()