链表的奇偶重排

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param head ListNode类 
# @return ListNode类
#
class Solution:
    def oddEvenList(self , head: ListNode) -> ListNode:
        # write code here
        if head is None:
            return None
        ji = []
        ou = []
        count = 1
        while head:
            if count  %2==1:
                ji.append(head.val)
                head = head.next
                count += 1
            else:
                ou.append(head.val)
                head = head.next
                count+=1
        
        for i in ou:
            ji.append(i)
        res = ListNode(0)
        temp = res
        for i in ji :
            temp. next = ListNode(i)
            temp = temp.next
        return res.next

#对于不会双指针的小白，可以记记链表列表相互转换的代码，缺点就是运行稍慢
class Solution:
    def oddEvenList(self , head: ListNode) -> ListNode:
        #链表转列表
        result = []
        while head:
            result.append(head.val)
            head = head.next
        #奇数偶数分开
        a = []
        b = []
        for i in range(len(result)):
            if i % 2 == 1:
                a.append((result[i]))
            elif i % 2 == 0:
                b.append((result[i]))
        c = b + a
        print(c)
        #列表转链表
        if not c:
            return None
        head = ListNode(c[0])
        r = head
        for value in c[1:]:
            r.next = ListNode(value)
            r = r.next
        return head

class Solution:
    def oddEvenList(self , head: ListNode) -> ListNode:
        # write code here
        p1 = ListNode(0)
        p2 = ListNode(0)
        even = p1
        odd = p2
        next = None  # 记录下一个head节点
        while head != None and head.next != None:
            # 处理奇数节点
            next = head.next
            # 断开head节点
            head.next = None
            p1.next = head
            head = next
            # 处理偶数节点
            next = head.next
            head.next = None
            p2.next = head
            head = next
            # 指针指向next节点 
            p1 = p1.next
            p2 = p2.next
        if head != None:
            p1.next = head
            p1 = p1.next
        # 连接
        p1.next = odd.next
        return even.next

算法小白，想请教一下，面对链表可以转化成列表处理然后再转化为链表嘛？

class Solution:
    def oddEvenList(self , head: ListNode) -> ListNode:
        # write code here
        nums = []
        pre = head
        while pre:
            nums.append(pre.val)
            pre = pre.next

        nums_sorted = nums[0::2] + nums[1::2] # 按照要求将奇数位排在前面，偶数位排在后面

        pre = head
        for i in nums_sorted:
            pre.val = i
            pre = pre.next
        return head

class Solution:
    def oddEvenList(self , head: ListNode) -> ListNode:
        # write code here
        evenHead = head.next # 偶数的第一个
        odd = head # 奇数
        even = head.next # 偶数
        while even and even.next:
            odd.next = even.next # 奇数指向奇数
            odd = odd.next
            even.next = odd.next # 偶数指向偶数
            even = even.next
        odd.next = evenHead # 奇数最后一个指向偶数第一个
        return head