设计一个算法，将链表中所有结点的链接方向“原地”逆转，即要求仅利用原表的存储空间，换句话说，要求算法的空间复杂度为O(1) 完整算法代码

要实现链表的原地逆转，你可以使用迭代的方式来完成。这里是一个简单的C++算法：

#include <iostream>

// 链表节点结构
struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

ListNode* reverseList(ListNode* head) {
    if (head == nullptr || head->next == nullptr) { // 如果链表为空或只有一个元素，直接返回
        return head;
    }

    ListNode* prev = nullptr; // 前驱节点指针
    ListNode* curr = head; // 当前节点指针

    while (curr != nullptr) {
        ListNode* temp = curr->next; // 保存当前节点的下一个节点
        curr->next = prev; // 将当前节点的next指向前一个节点
        prev = curr; // 更新前驱节点为当前节点
        curr = temp; // 移动到下一个节点
    }
    
    return prev; // 返回新的头节点（原来的尾部）
}

// 打印链表
void printList(ListNode* head) {
    while (head != nullptr) {
        std::cout << head->val << " -> ";
        head = head->next;
    }
    std::cout << "nullptr\n";
}

int main() {
    // 创建一个示例链表
    ListNode* list = new ListNode(1);
    list->next = new ListNode(2);
    list->next->next = new ListNode(3);
    list->next->next->next = new ListNode(4);

    std::cout << "Original List:\n";
    printList(list);

    list = reverseList(list);

    std::cout << "Reversed List:\n";
    printList(list);

    return 0;
}

这个算法的时间复杂度是O(n)，其中n是链表的长度，因为每个节点都要被遍历一次。空间复杂度是O(1)，因为我们只使用了几个额外的指针变量，没有创建新的数据结构来存储信息。