【算法入门】反转单链表(C语言实现)

本文介绍了一个简单的链表反转算法实现,通过定义结构体和指针操作,实现了链表的自动创建和反转。代码中详细展示了如何遍历链表,创建新节点,并进行链表反转的过程。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >


#include "stdio.h"
#include "stdlib.h"

typedef struct linkList{
        int data;
        struct linkList* next;
}*linkList, listNode;

linkList reserveList(linkList list);
linkList autoCreateList();

linkList autoCreateList(){
        int data[4] = {1, 2, 3, 4};
        int i;
        linkList list = (linkList)malloc(sizeof(listNode));
        linkList temp;
        listNode* newNode;

        list->data = data[0];
        list->next = NULL;
        temp = list;

        for(i=1; i<4; i++){
                newNode = (listNode*)malloc(sizeof(listNode));
                newNode->data = data[i];
                temp->next = newNode;
                temp = newNode;
        }

        temp->next = NULL;
        return list;
}

linkList reserveList(linkList list){
        listNode *next, *prev;
        next = NULL;
        prev = NULL;

        if(list==NULL){
                return NULL;
        }

        while(list!=NULL){
                next = list->next;
                list->next = prev;
                prev = list;
                list = next;
        }

        return prev;
}
int main(){
        linkList list;
        list = autoCreateList();
        list = reserveList(list);

        while(list!=NULL){
                printf("%d ", list->data);
                list = list->next;
        }

        return 0;
}

### C语言实现链表反转的方法 在C语言中,链表反转可以通过多种方法实现。以下将介绍几种常见的实现方式,并附上代码示例。 #### 方法一:迭代法 迭代法是通过逐步修改链表中每个节点的`next`指针来实现反转。这种方法的核心思想是使用三个指针分别指向当前节点、前驱节点和后继节点,确保在修改指针时不会丢失链表结构[^3]。 ```c struct ListNode* ReverseList(struct ListNode* head) { struct ListNode *pre = NULL, *cur = head, *nxt = NULL; while (cur) { nxt = cur->next; // 保存下一个节点 cur->next = pre; // 当前节点指向前驱节点 pre = cur; // 更新前驱节点 cur = nxt; // 移动到下一个节点 } return pre; // 返回新的头节点 } ``` #### 方法二:递归法 递归法是一种更简洁但逻辑上稍复杂的实现方式。其基本思路是从链表尾部开始逐层反转,直到到达原始头节点[^2]。 ```c struct ListNode* reverseList(struct ListNode* head){ if (head == NULL || head->next == NULL) { return head; // 基本情况:如果链表为空或只有一个节点,则直接返回 } struct ListNode* n1 = NULL, *n2 = head, *n3 = head->next; while (n2) { // 停止条件:当n2为空指针时代表循环结束 n2->next = n1; // 反转 n1 = n2; // 迭代 n2 = n3; if (n3) { // 注意n3可能访问到空指针 n3 = n3->next; } } return n1; // 返回新的头节点 } ``` #### 方法三:新建链表(头插法) 此方法通过创建一个新的链表,并将原链表中的每个节点以头插法的方式插入到新链表中,从而实现链表反转[^1]。 ```c #include <stdlib.h> typedef struct node { int data; struct node* next; } Node; Node* reverseList(Node* head) { Node* newHead = NULL; Node* current = head; while (current != NULL) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = current->data; newNode->next = newHead; newHead = newNode; current = current->next; } return newHead; } ``` #### 方法四:图形化理解与逻辑分析 从逻辑上看,链表反转的关键在于改变每个节点的`next`指针方向。例如,原本`cur->next = next`,现在需要让`cur->next = prev`,同时确保断开原来的连接[^4]。 ```c void reverseListLogic(struct ListNode** head_ref) { struct ListNode* prev = NULL; struct ListNode* current = *head_ref; struct ListNode* next = NULL; while (current != NULL) { next = current->next; // 保存下一个节点 current->next = prev; // 修改当前节点的指针 prev = current; // 移动prev和current current = next; } *head_ref = prev; // 更新头节点 } ``` ### 总结 以上介绍了四种实现链表反转的方法,包括迭代法、递归法、新建链表(头插法)以及逻辑分析。每种方法各有优劣,选择时需根据具体场景和需求进行权衡。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值