Python 奇偶链表（索引组合 && 数值组合）

给定单链表的头节点 head ，将所有索引为奇数的节点和索引为偶数的节点分别组合在一起，然后返回重新排序的列表。

第一个节点的索引被认为是 奇数 ， 第二个节点的索引为 偶数 ，以此类推。

请注意，偶数组和奇数组内部的相对顺序应该与输入时保持一致。

你必须在 O(1) 的额外空间复杂度和 O(n) 的时间复杂度下解决这个问题。

示例 1:

输入: head = [1,2,3,4,5]
输出: [1,3,5,2,4]

示例 2:

输入: head = [2,1,3,5,6,4,7]
输出: [2,3,6,7,1,5,4]

算法逻辑

通过链表的位置查找，只需建立函数实现输入元素的位置下标返回元素的值即可，也就是把链表当成数组用

代码实现

通过输入链表的下标num，随后开始遍历链表直至第num个节点的是停止遍历并返回该节点的值

    def value(self,num):
        if self.head == None:
            return
        else:
            current = self.head
            count = 0
            while current.next and count < num:
                current = current.next
                count += 1
            return current.data

本题以索引的奇偶性进行组合的，当然也可能有通过链表节点值的奇偶性组合的情况，这里博主将两种情况都写了出来，但是需要注意的是，通过for循环遍历链表需要知道链表的长度，链表长度的返回方法和访问节点的方法一致，略有不同而已

若想知道更多的单链表操作，可以浏览博主的个人空间

返回链表长度

    def len(self):
        if self.head == None:
            return
        else:
            current = self.head
            count = 1
            while current.next:
                current = current.next
                count += 1
            return count

索引奇偶性组合

PS：第一个索引被认为是奇数，所以偶数索引将会是被认为是奇数，因为索引从0开始，0为偶数

def index_sort(input_list):
    result = linked_list()
    for i in range(input_list.len()):
        if i % 2 == 0:  # 第一个索引被认为是奇数，所以偶数索引将会是被认为是奇数，因为索引从0开始，0为偶数
            result.insert(input_list.value(i))
    for i in range(input_list.len()):
        if i % 2 == 1:
            result.insert(input_list.value(i))
    return result

数值奇偶性组合

时间复杂度为O(n)

def value_sort(input_list):
    result = linked_list()
    for i in range(input_list.len()):
        if input_list.value(i) % 2 == 0:
            result.insert(input_list.value(i))
    for i in range(input_list.len()):
        if input_list.value(i) % 2 == 1:
            result.insert(input_list.value(i))
    return result

完整代码

时间复杂度为O(n)

class node:
    def __init__(self,data):
        self.data = data
        self.next = None
class linked_list:
    def __init__(self):
        self.head = None
    def insert(self,data):
        new_node = node(data)
        if self.head == None:
            self.head = new_node
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = new_node
    def len(self):
        if self.head == None:
            return
        else:
            current = self.head
            count = 1
            while current.next:
                current = current.next
                count += 1
            return count
    def value(self,num):
        if self.head == None:
            return
        else:
            current = self.head
            count = 0
            while current.next and count < num:
                current = current.next
                count += 1
            return current.data
    def display(self):
        if self.head == None:
            return
        else:
            current = self.head
            while current.next:
                print(current.data,end = "->")
                current = current.next
            print(current.data)

def value_sort(input_list):
    result = linked_list()
    for i in range(input_list.len()):
        if input_list.value(i) % 2 == 0:
            result.insert(input_list.value(i))
    for i in range(input_list.len()):
        if input_list.value(i) % 2 == 1:
            result.insert(input_list.value(i))
    return result

def index_sort(input_list):
    result = linked_list()
    for i in range(input_list.len()):
        if i % 2 == 0:  # 第一个索引被认为是奇数，所以偶数索引将会是被认为是奇数，因为索引从0开始，0为偶数
            result.insert(input_list.value(i))
    for i in range(input_list.len()):
        if i % 2 == 1:
            result.insert(input_list.value(i))
    return result

list = linked_list()
list.insert(1)
list.insert(2)
list.insert(3)
list.insert(4)
list.insert(5)
print("链表：")
list.display()
print("按照链表节点数值的奇偶性排列：")
value_sort(list).display()
print("按照链表节点索引的奇偶性排列：")
index_sort(list).display()


list_0 = linked_list()
list_0.insert(2)
list_0.insert(1)
list_0.insert(3)
list_0.insert(5)
list_0.insert(6)
list_0.insert(4)
list_0.insert(7)
print("链表：")
list_0.display()
print("按照链表节点数值的奇偶性排列：")
value_sort(list_0).display()
print("按照链表节点索引的奇偶性排列：")
index_sort(list_0).display()

在评论区留下你的意见以及建议，重要的是自己试试看吧，你会做的更好