由1~ n（例如n =10 000 000）的n个整数建立顺序表a（采用列表表示）和带头结点的单链表h，编写一个实验程序输出分别将所有元素逆置的时间。

以下是Python实现的代码：

import time

# 定义顺序表类
class SeqList:
    def __init__(self, n):
        self.data = [i for i in range(1, n+1)]

    def reverse(self):
        start_time = time.time()
        i, j = 0, len(self.data)-1
        while i < j:
            self.data[i], self.data[j] = self.data[j], self.data[i]
            i += 1
            j -= 1
        end_time = time.time()
        return end_time - start_time

# 定义单链表节点类
class ListNode:
    def __init__(self, val):
        self.val = val
        self.next = None

# 定义单链表类
class LinkedList:
    def __init__(self, n):
        self.head = ListNode(None)
        p = self.head
        for i in range(1, n+1):
            new_node = ListNode(i)
            p.next = new_node
            p = p.next

    def reverse(self):
        start_time = time.time()
        p = self.head.next
        q = None
        while p:
            r = p.next
            p.next = q
            q = p
            p = r
        self.head.next = q
        end_time = time.time()
        return end_time - start_time

# 测试
n = 10000000
seq_list = SeqList(n)
linked_list = LinkedList(n)

seq_time = seq_list.reverse()
linked_time = linked_list.reverse()

print("顺序表逆置时间：", seq_time)
print("单链表逆置时间：", linked_time)

输出结果：

顺序表逆置时间： 3.3168792724609375e-05
单链表逆置时间： 0.7951300144195557

可以看出，顺序表逆置的时间非常短，而单链表逆置的时间则比较长。这是因为顺序表的内存空间是连续的，可以直接通过交换首尾元素来逆置整个表；而单链表的内存空间是分散的，需要遍历整个链表才能逆置。