#include <stdio.h>
#include <stdlib.h>
这两行是包含标准的输入输出库和动态内存分配库，以便你能够使用 printf、scanf 和 malloc 函数。

struct Node{//定义一个结构体类型 作为节点 
    int data;//存储整型数据 
    struct Node* next;//存储下一个节点的地址 
};

这里定义了一个结构体 Node，表示链表的节点。每个节点包含一个整型数据 data 和一个指向下一个节点的指针 next。

struct Node* Reverse(struct Node* head){
    struct Node *current,*next,*prev;
    /*指向节点的指针current,next,prev 
    存储当前节点的current   存储前一个节点的prev  */

这里定义了一个名为 Reverse 的函数，用于反转链表。函数接受一个指向链表头节点的指针作为参数，并返回反转后的链表头节点的指针。在函数内部，定义了三个指针变量 current、next 和 prev，用来遍历链表并记录当前节点、下一个节点和前一个节点的地址。
   

current=head;//current指针指向链表的头节点head
    prev=NULL;

将 current 指针指向链表的头节点 head，将 prev 初始化为空指针，表示当前节点的前一个节点为空。

  while(current!=NULL){//temp非空时 遍历链表 
        next = current->next ;//指针next指向当前节点的下一个节点 
        current->next = prev ;//当前节点的next指针指向前一个节点 
        prev = current;//prev指针指向当前节点
        current = next;//current指针指向下一个节点
    } 

在一个 while 循环中，遍历整个链表。在每一次循环中，先将 next 指针指向当前节点 current 的下一个节点，以便在修改当前节点的 next 指针时不丢失对下一个节点的引用。然后将当前节点的 next 指针指向前一个节点 prev，从而实现链表的反转。最后，更新 prev 为当前节点 current，current 更新为下一个节点 next。

  

 //head指针指向反转后的链表的头节点，并返回head指针
    head = prev;
    return head;
}循环结束后，将链表的头节点指针 head 更新为反转后的链表的头节点 prev，然后返回 head 指针。

Node*Insert(Node* head,int data){
    Node *temp = (struct Node*)malloc(sizeof(struct Node));
    temp->data = data;
    temp->next = NULL;

这是一个插入节点的函数 Insert，接受一个指向链表头节点的指针 head 和要插入的整数数据 data。函数首先动态分配一个新节点 temp，然后将新节点的数据域 data 设置为传入的数据，将新节点的指针域 next 设置为 NULL。

    if(head==NULL) head=temp;
    else {
        Node* temp1 = head;
        while(temp1->next !=NULL) temp1=temp1->next;
        temp1->next = temp;
    }
    return head;
}

接着，函数检查链表是否为空。如果链表为空，则将 head 指针指向新节点 temp。否则，遍历链表直到找到最后一个节点，然后将新节点连接到链表的末尾。

void Print(Node* head){
    while(head!=NULL){
       printf("%d ",head->data );
        head = head ->next;
    }
}

这是一个打印链表节点数据的函数 Print，接受一个指向链表头节点的指针 head。函数通过循环遍历链表，逐个打印每个节点的数据，并将指针移动到下一个节点。

int main(){
    struct Node* head=NULL;
    head=Insert(head,2);
    head=Insert(head,4);
    head=Insert(head,6);
    head=Insert(head,8);
    Print(head);
    head=Reverse(head);
    Print(head);
}

最后，在 main 函数中，你创建了一个空链表，然后依次插入了四个节点（2、4、6、8），然后调用 Print 函数打印原始链表。接着调用 Reverse 函数反转链表，再次调用 Print 函数打印反转后的链表。

//迭代方式实现链表反转
#include <stdio.h>
#include <stdlib.h>
struct Node{//定义一个结构体类型 作为节点 
	int data;//存储整型数据 
	struct Node* next;//存储下一个节点的地址 
};
 
struct Node* Reverse(struct Node* head){
	struct Node *current,*next,*prev;
	/*指向节点的指针current,next,prev 
	存储当前节点的current  
	存储下一个节点的next 
	存储前一个节点的prev  */
	 
	current=head;//current指针指向链表的头节点head
	prev=NULL;
	
	while(current!=NULL){//temp非空时 遍历链表 
		next = current->next ;//指针next指向当前节点的下一个节点 
		current->next = prev ;//当前节点的next指针指向前一个节点 
		prev = current;//prev指针指向当前节点
		current = next;//current指针指向下一个节点
	} 
	//head指针指向反转后的链表的头节点，并返回head指针
	head = prev;
	return head;
}

Node*Insert(Node* head,int data){
	Node *temp = (struct Node*)malloc(sizeof(struct Node));
	temp->data = data;
	temp->next = NULL;
	if(head==NULL) head=temp;
	else {
		Node* temp1 = head;
		while(temp1->next !=NULL) temp1=temp1->next;
		temp1->next = temp;
	}
	return head;
}

void Print(Node* head){
	while(head!=NULL){
		printf("%d ",head->data );
		head = head ->next;
	}
}

int main(){
	struct Node* head=NULL;
	head=Insert(head,2);
	head=Insert(head,4);
	head=Insert(head,6);
	head=Insert(head,8);
	Print(head);
	head=Reverse(head);
	Print(head);
	return 0;
}