有一个整数单链表L，设计一个算法逆置L中的所有节点

有一个整数单链表L，设计一个算法逆置L中的所有节点。直接把代码给我

```python
class Node:
    def __init__(self,data):
        self.data = data
        self.next = None
        
def createByTail(a):
    head = Node(-1)
    tail = head
    for i in range(len(a)):
        p = Node(a[i])
        tail.next = p
        tail = p

    return head

def output(head):
    p = head.next
    while p!=None:
        if p!= head.next:
            print(' ',end='')
        print(p.data,end='')
        p = p.next
    print()

def reverse(head):
    p = head.next
    head.next = None
    while p != None:
        q = p
        p = p.next
        q.next = head.next
        head.next = q

if __name__ == '__main__':
    T = int(input())
    for t in range(T):
        a = list(map(int,input().split()))
        a = a[:len(a)-1]
        h = createByTail(a)
        reverse(h)
        output(h)

```

class Node:
    def __init__(self,data):
        self.data = data
        self.next = None
        
def createByTail(a):
    head = Node(-1)
    tail = head
    for i in range(len(a)):
        p = Node(a[i])
        tail.next = p
        tail = p

    return head

def output(head):
    p = head.next
    while p!=None:
        if p!= head.next:
            print(' ',end='')
        print(p.data,end='')
        p = p.next
    print()

def reverse(head):
    p = head.next
    head.next = None
    while p != None:
        q = p
        p = p.next
        q.next = head.next
        head.next = q

if __name__ == '__main__':
    T = int(input())
    for t in range(T):
        a = list(map(int,input().split()))
        a = a[:len(a)-1]
        h = createByTail(a)
        reverse(h)
        output(h)

http://t.csdn.cn/NKcnO
代码在这里面，有解析与用法，有帮助记得采纳

class Node:
    def __init__(self,data):
        self.data = data
        self.next = None
        
def createByTail(a):
    head = Node(-1)
    tail = head
    for i in range(len(a)):
        p = Node(a[i])
        tail.next = p
        tail = p

    return head

def output(head):
    p = head.next
    while p!=None:
        if p!= head.next:
            print(' ',end='')
        print(p.data,end='')
        p = p.next
    print()

def reverse(head):
    p = head.next
    head.next = None
    while p != None:
        q = p
        p = p.next
        q.next = head.next
        head.next = q

if __name__ == '__main__':
    T = int(input())
    for t in range(T):
        a = list(map(int,input().split()))
        a = a[:len(a)-1]
        h = createByTail(a)
        reverse(h)
        output(h)

    //将整个链表逆序(带表头节点)
    if (head->next!=NULL && head->next->next!=NULL) {
        p=head->next;
        q=p->next;
        p->next=NULL;
        while (1) {
            q1=q->next;
            q->next=p;
            p=q;
            q=q1;
            if (NULL==q) break;
        }
        head->next=p;
    }

   //将整个链表逆序(不带表头节点)
        p=head;
        if (p) q=p->next;
        if (q) {
            p->next=NULL;
            while (1) {
                q1=q->next;
                q->next=p;
                p=q;
                q=q1;
                if (NULL==q) break;
            }
            head=p;
       }

可以使用迭代或递归的方法来逆置单链表。

迭代方法：

初始化当前节点为单链表的头节点，并将前一个节点设置为NULL。
将当前节点的下一个节点设置为前一个节点。
将前一个节点设置为当前节点。
将当前节点设置为当前节点的下一个节点。
重复步骤2-4，直到当前节点为NULL。

struct Node 
{
  int data;
  Node* next;
};

Node* reverse(Node* head) 
{
  Node* current = head;
  Node* prev = NULL;

  while (current != NULL) 
  {
    Node* next = current->next;
    current->next = prev;
    prev = current;
    current = next;
  }

  return prev;
}

递归方法：

如果单链表为空或者只有一个节点，则返回头节点。
否则，递归地逆置剩余部分的所有节点。
将当前节点的下一个节点设置为当前节点。
将当前节点设置为递归调用返回的节点。

struct Node 
{
  int data;
  Node* next;
};

Node* reverse(Node* head) 
{
  if (head == NULL || head->next == NULL) 
  {
    return head;
  }

  Node* reversed = reverse(head->next);
  head->next->next = head;
  head->next = NULL;
  return reversed;
}